Claude Code SDLC

Turn Claude Code into a full software development team.

12 specialized AI agents. Documentation-first pipeline. TDD enforcement. Quality gates before every merge.

---

What Is This?

When you install this, Claude Code stops being a single assistant and becomes a 12-person development agency. Every feature goes through a structured pipeline — from requirements documentation to architecture review to test-driven implementation to quality gates.

No more "just write the code." Every change is documented, planned, reviewed, tested, and verified.

Who Is This For?

• Solo developers who want production-quality output from Claude Code
• Tech leads who want Claude to follow their team's process
• Teams that want structured, reviewable AI-assisted development
• Anyone tired of Claude skipping tests, ignoring architecture, or writing code before understanding requirements

Quick Install

curl -fsSL https://raw.githubusercontent.com/Koroqe/claude-code-sdlc/main/install.sh | bash

Or clone and install locally:

git clone https://github.com/Koroqe/claude-code-sdlc.git
cd claude-code-sdlc
bash install.sh --yes

To also scaffold a new project:

bash install.sh --init-project

---

How It Works

Every feature flows through a structured pipeline:

  Feature Request
       |
       v
  +-----------+
  | PLAN MODE |  Explore codebase -> Design approach -> Plan Critic review
  +-----------+
       |
       v  (user approves)
  +---------------------+
  | /bootstrap-feature  |
  +---------------------+
       |
       +---> PRD Writer .............. documents requirements
       +---> Business Analyst ........ writes use cases
       +---> Architect ............... reviews design
       +---> QA Lead ................. documents test cases
       +---> Tech Lead ............... creates implementation plan
       |
       v
  +---------------------+
  | /implement-slice    |  (loops for each slice)
  +---------------------+
       |
       +---> Write tests first (TDD)
       +---> Implement to pass tests
       +---> Verify: typecheck + tests + build
       +---> Commit
       |
       v
  +---------------------+
  | /merge-ready        |
  +---------------------+
       |
       +---> Code Review
       +---> Security Audit
       +---> Build Verification
       +---> E2E Tests
       +---> Documentation Check
       |
       v
  MERGE READY

The Pipeline In Detail

Phase	What Happens	Who Does It
Plan	Explore codebase, design approach, write plan, critic review	You + Claude
Bootstrap	PRD, use cases, architecture review, QA test cases, implementation plan	5 agents
Implement	TDD slices: tests first, implement, verify, commit	2 agents per slice
Quality Gates	Code review, security audit, build, E2E tests, docs check	5 agents

---

The Agency

12 specialized agents, each with a clear role:

Role	Agent	What It Does
Product Manager	prd-writer	Documents feature requirements in docs/PRD.md
Business Analyst	ba-analyst	Analyzes use cases and scenarios in docs/use-cases/
Software Architect	architect	Reviews architecture decisions, validates boundaries
QA Lead	qa-planner	Documents test cases in docs/qa/ before any code
Tech Lead	planner	Breaks features into 5-9 testable implementation slices
Security Engineer	security-auditor	Audits for vulnerabilities, checks auth boundaries
Developer	test-writer	Writes tests following TDD — tests before implementation
QA Engineer	e2e-runner	Creates and runs end-to-end tests from use cases
Code Reviewer	code-reviewer	Reviews for quality, security, and architecture compliance
DevOps	build-runner	Runs typecheck, tests, and build verification
Tech Writer	doc-updater	Keeps documentation accurate after changes
Senior Developer	refactor-cleaner	Post-implementation cleanup and code quality

---

Pipeline Commands

Command	Description
/develop-feature	Full autonomous pipeline — from request to merge-ready
/bootstrap-feature	Documentation phases only — PRD, use cases, architecture, QA, plan
/implement-slice	Implement the next TDD slice — tests first, then code
/merge-ready	Run all quality gates — code review, security, build, E2E, docs
/context-refresh	Rebuild session context from scratchpad (for long sessions)

Usage

Just start Claude Code and describe what you want:

> Add user authentication with Google OAuth

Claude will automatically:
1. Enter plan mode → explore codebase → design approach → critic review
2. Run /bootstrap-feature → PRD → use cases → architecture → QA → plan
3. Loop /implement-slice → TDD for each slice
4. Run /merge-ready → all quality gates pass

Or use commands directly:

> /develop-feature Add a notification system for low balance alerts

---

Project Setup

When starting a new project, scaffold the SDLC structure:

cd your-project
bash install.sh --init-project

This creates:

.claude/
  CLAUDE.md              # Your project's tech stack, structure, commands (fill in TODOs)
  scratchpad.md          # Session state persistence
  settings.json          # Permissions config
  rules/
    architecture.md      # Module boundaries and constraints
    security.md          # Security requirements
    testing.md           # Test setup and commands

docs/
  PRD.md                 # Product requirements document
  qa/                    # QA test case directory
  use-cases/             # Use case document directory

Fill in the TODOs in .claude/CLAUDE.md with your project's actual tech stack, commands, and architecture. The more context you provide, the better the agents perform.

---

What Gets Installed

The installer adds files to ~/.claude/ (user-level, applies to all projects):

~/.claude/
  claude.md              # Main workflow instructions
  agents/                # 12 agent prompt files
    architect.md
    ba-analyst.md
    build-runner.md
    code-reviewer.md
    doc-updater.md
    e2e-runner.md
    planner.md
    prd-writer.md
    qa-planner.md
    refactor-cleaner.md
    security-auditor.md
    test-writer.md
  commands/              # 5 pipeline commands
    bootstrap-feature.md
    context-refresh.md
    develop-feature.md
    implement-slice.md
    merge-ready.md
  rules/                 # 3 process rules
    error-recovery.md
    git.md
    scratchpad.md

---

Customization

Modify Agent Prompts

Each agent is a standalone markdown file. Edit them directly:

# Example: make the architect more strict about module boundaries
vim ~/.claude/agents/architect.md

Or fork this repo, edit in src/agents/, and reinstall:

bash install.sh --local --yes

Add New Agents

Create a new .md file in src/agents/ (or ~/.claude/agents/):

---
name: your-agent
description: What it does
tools: ["Read", "Glob", "Grep"]
model: sonnet
---

# Agent Title

Instructions for the agent...

Change Models

Each agent specifies its model in the frontmatter. Change model: sonnet to opus or haiku based on your needs and budget.

---

Key Concepts

Documentation-First

Every feature starts with documentation — PRD, use cases, test cases — before any code is written. This ensures Claude understands the full scope before implementing.

TDD Enforcement

Tests are written before implementation. The test-writer agent creates failing tests, then code is written to make them pass.

Plan Critic

After writing a plan, an adversarial "critic" agent reviews it for missing dependencies, vague requirements, wrong file paths, and oversized slices. This catches issues before implementation starts.

Scratchpad Persistence

The .claude/scratchpad.md file survives context compaction during long sessions. Progress, current slice, and blockers are always available.

Use Case-Driven

The Business Analyst creates comprehensive use-case documents that drive both QA test cases and E2E tests. Every test traces back to a documented scenario.

---

Contributing

See CONTRIBUTING.md for how to improve agent prompts, add new agents, and submit changes.

License

MIT