LLM-Assisted Development Frameworks

A collection of Claude Code frameworks for LLM-assisted software development, covering both greenfield projects and incremental feature development on existing codebases.

Author: Gamcorn

---

Frameworks

Framework	Best For	Starting Point
from_scratch/	New projects	Empty directory
features_and_tests/	Existing codebases	Working project

---

Prerequisites

Both frameworks require:

• Python 3.11+
• Claude Code CLI installed and authenticated
• Git
• Docker (recommended for from_scratch/)

Install Claude Code

npm install -g @anthropic-ai/claude-code

Then authenticate:

claude

Install CCLSP (if needed)

Recommended when working in large existing codebase, useless for from scratch projects

CCLSP makes code navigation faster and more token-efficient. Both frameworks reference it.

# Follow installation instructions at github.com/ktnyt/cclsp

---

Framework 1: Greenfield Bootstrap (from_scratch/)

Start a brand-new project with architecture-first design and automatic test generation.

Setup

1. Copy the framework to your new project directory:

   cp -r from_scratch/ ~/projects/my-new-project
   cd ~/projects/my-new-project

2. Open Claude Code in the project:

   claude

3. Initialize the project:

   /init-project
   

   You will be prompted for:

   • Project name
   • Description
   • Technology stack (Web API / CLI Tool / Library)
   • Accept or customize defaults

Workflow

/init-project           →  Scaffold project structure and tech stack
/define-architecture    →  Design modules and interface contracts
/implement-module core  →  Build Layer 0 (config, logging, database)
/implement-module <name>→  Build domain/service modules layer by layer
/integrate-modules      →  Wire all modules into working application
/add-migrations         →  Add Alembic database migrations (optional)

Build Order

Always build bottom-up:

Layer 0: Core          →  First (config, logging, DB — no dependencies)
Layer 1: Domains       →  Second (users, orders, products…)
Layer 2: Services      →  Third (payment, email, auth…)
Layer 3: API / CLI     →  Last (routes, commands)

Supported Project Types

Type	Stack
Web API	FastAPI, Pydantic v2, SQLAlchemy 2.0, PostgreSQL, Docker
CLI Tool	Typer, Rich, Pydantic Settings, SQLite (optional)
Library	Pure Python, minimal dependencies

---

Framework 2: Feature-Driven Development (features_and_tests/)

Add features and fix bugs in an existing codebase with automatic test generation (85%+ coverage) and user-controlled checkpoints.

Setup

1. Copy the framework into your existing project:

   # Copy the .claude/ directory and supporting files
   cp -r features_and_tests/.claude/   ~/projects/my-existing-project/.claude/
   cp    features_and_tests/CLAUDE.md  ~/projects/my-existing-project/CLAUDE.md
   cp    features_and_tests/.coveragerc ~/projects/my-existing-project/.coveragerc
   
   # Copy the docs scaffolding
   cp -r features_and_tests/docs/      ~/projects/my-existing-project/docs/

2. Edit CLAUDE.md to describe your project's principles, invariants, and directory structure.

3. Open Claude Code in your project:

   cd ~/projects/my-existing-project
   claude

Workflow

/create-work-item       →  Define a feature spec or bug report
/implement-work-item    →  Implement with automatic test generation
/arch-design            →  Design interfaces and architecture
/arch-review            →  Review architecture decisions
/audit-docs             →  Keep documentation accurate
/review-tests           →  Review test quality
/session                →  Analyze past Claude Code sessions

Work Item Lifecycle

1. /create-work-item   — Analyze codebase and write spec
   ↓ Approval checkpoint
2. /implement-work-item — Implement code + auto-generate tests
   ↓ 6 approval checkpoints (plan → code → tests → review → final)
3. Stage changes       — Review diff, then commit manually
4. Archive work item   — Move to docs/work-items/archive/

Coverage Configuration

Edit .coveragerc to set:

• Target: 85% minimum (default)
• Source directories to measure
• Files/patterns to exclude

---

Key Design Principles (Both Frameworks)

• No automatic commits — all changes are staged for your review
• Approval checkpoints — you approve every major step
• Specialized agents — architect, implementer, test-creator, reviewer each work in isolation
• 85%+ test coverage — automatic test generation with up to 3 retry cycles
• Code is truth — after implementation, docs reference code, not the other way around

---

Repository Structure

llm_assisted_dev/
├── README.md                    # This file
├── from_scratch/                # Greenfield bootstrap framework
│   ├── CLAUDE.md                # Framework principles
│   ├── docs/
│   │   ├── BUILD.md             # Build guide and checklist
│   │   └── architecture/        # Module index and interface contracts
│   └── .claude/
│       ├── agents/              # Architect, implementer, test-creator
│       └── skills/              # init-project, define-architecture, etc.
└── features_and_tests/          # Feature/bug-driven framework
    ├── CLAUDE.md                # Framework principles (template)
    ├── CUSTOMIZATION.md         # How to adapt to your project
    ├── .coveragerc              # Coverage configuration
    ├── docs/
    │   ├── CAPABILITIES.md
    │   ├── SCRATCHPAD.md
    │   └── work-items/          # Feature and bug spec templates
    └── .claude/
        ├── agents/              # Architect, implementer, test-creator
        └── skills/              # create-work-item, implement-work-item, etc.

---

Choosing a Framework

Use from_scratch/ when:

• Starting from an empty directory
• You need to choose a tech stack
• You want architecture-first, layer-by-layer development

Use features_and_tests/ when:

• You have a working codebase and want to add features or fix bugs
• You need automatic test generation for new code
• You want structured specs and user-controlled approval gates

---

License

These are templates and frameworks. Use them however you want for your projects.

Acknowledgments

Both frameworks are based on the Claude Code Project Template by ktnyt, significantly adapted for feature-driven and greenfield development workflows.