Which Development Methodology Fits Your Workflow?
AI-assisted development doesn't mean using Claude the same way for every project. Different team sizes, maturity levels, and contexts need different approaches.
Which Development Methodology Fits You?
Answer 12 short questions about how you work. We will match you to the methodology stack that fits your workflow, team size, and context — not just a single technique.
Question text
Your Methodology Stack
Best match
Also a good fit
The Two-Axis Map
Every methodology sits somewhere on two axes. Knowing where you need to be narrows the field fast.
Spec-First vs Code-First
Spec-first methodologies (BMAD, SDD, BDD) require documentation before any code runs. Code-first methods (Ralph Loop, Iterative, TDD) let you start immediately and discover structure as you build.
Lean vs Enterprise
Lean methodologies minimize ceremony — one file, fast iteration, low coordination cost. Enterprise methods add traceability, multi-agent gates, and contract enforcement suited for high-complexity or compliance-driven projects.
Positioning map (20 methodologies)
SPEC / PLANNING FIRST
▲
── lean · spec ── │ ── governed · spec ──
│
[Doc-Driven] [SDD] │ [BDD] [ATDD] [Req-Driven]
[GSD] [Plan-First] │ [CDD] [ADR-Driven] [DDD] [BMAD]
│
LEAN ─────────────────────────┼────────────────────────────────► ENTERPRISE
│
── lean · code ── │ ── governed · code ──
│
[Context Eng.] [TDD] │ [Multi-Agent]
[Prompt Eng.] [Iterative] │ [Eval-Driven] [FDD]
[Ralph Loop] │ [JiTTesting]
│
CODE / EMERGENTFull guide section with quadrant analysis: cc.bruniaux.com/guide/methodologies/
8 Recommended Stacks
Individual methodologies don't work in isolation. These stacks combine 2–3 methods that reinforce each other.
Solo MVP Builder
Minimal overhead, maximum quality. Write a short spec in CLAUDE.md, then TDD your way to a working MVP. The spec prevents scope creep; the tests prevent regressions. Natural fit for solo developers who want to ship fast without cutting corners.
Quick start
Create a CLAUDE.md with your feature spec, then: "Write failing tests for this spec, then implement until they pass."
Team Greenfield
Governance meets collaboration. Spec Kit gives you a constitution and structured requirements. BDD scenarios let product and dev speak the same language. TDD ensures every behavior is tested. The investment pays off from day one on team projects.
Quick start
Run /speckit.constitution to set guardrails, write Given/When/Then scenarios with your PM, then TDD each scenario.
API Contract Stack
Contract-first, parallel development. Define your OpenAPI specs before writing a line of code. Specmatic auto-generates tests and stubs from those contracts, so teams can develop independently without integration surprises. TDD handles the implementation behind each contract.
Quick start
Write your OpenAPI spec first, run Specmatic to generate contract tests and stubs, then TDD the implementation behind each endpoint.
Existing Product Evolution
Evolve without breaking. OpenSpec tracks what exists and what is changing, so specs never drift from reality. BDD scenarios document expected behavior for stakeholders. JiTTesting catches regressions at PR time without growing your test suite forever.
Quick start
Set up OpenSpec to capture current specs, write BDD scenarios for the feature you are changing, and add a pre-merge prompt: "Generate tests that catch regressions in this diff."
Enterprise Governance
Full governance for high-complexity projects. BMAD provides the constitution and multi-agent orchestration. Spec Kit structures requirements across teams. Specmatic enforces API contracts between services. High setup cost, but traceability and compliance are real. Note: BMAD requires stable requirements — it becomes a liability when specs change frequently mid-project.
Quick start
Start with BMAD constitution.md, define agent roles for your workflow, set up Spec Kit for requirements, and Specmatic for API contract testing.
AI Product Builder
TDD for AI outputs. When your product surfaces LLM responses to users, traditional tests are not enough. Eval-driven development gives you measurable quality gates for non-deterministic outputs. Multi-agent orchestration lets you build systems where specialized agents collaborate on complex tasks.
Quick start
Define eval criteria for your AI outputs (accuracy, safety, format), build an eval harness, then iterate until evals pass consistently.
Power User Loop
Autonomous iteration for experienced Claude users. TDD anchors quality. The Ralph Loop spawns fresh contexts per task so context rot never accumulates. Iterative loops let Claude converge autonomously on complex work. Minimal ceremony, maximum throughput.
Quick start
Set up a CLAUDE.md with your test command, use fresh context per task (git + progress files), and prompt: "Keep iterating until all tests pass and lint is clean."
Structured Planner
Think before you code, but do not over-engineer. Plan Mode forces exploration before execution. SDD captures the plan as a spec. Context Engineering ensures Claude has exactly the right information at each step. The sweet spot between ad-hoc coding and heavy governance.
Quick start
Start every complex task in Plan Mode (Shift+Tab), validate the plan, write the spec in CLAUDE.md, then execute with progressive context loading.
At a glance
| Stack | Methodologies | Best for | Setup | Team size |
|---|---|---|---|---|
| Solo MVP Builder | SDD + TDD | Solo, greenfield, quality-first | Minimal | 1 |
| Team Greenfield | Spec Kit + TDD + BDD | 5–10 devs, new project, shared understanding | Moderate | 2–10 |
| API Contract Stack | CDD + Specmatic + TDD | Microservices, parallel teams, explicit contracts | Moderate | 5–20 |
| Existing Product Evolution | OpenSpec + BDD + JiTTesting | Brownfield SaaS, 100+ features, no regressions | Moderate | 3–15 |
| Enterprise Governance | BMAD + Spec Kit + Specmatic | High-complexity projects, stable requirements, compliance | Heavy | Any |
| AI Product Builder | Eval-Driven + Multi-Agent | Product exposes AI to users, non-deterministic outputs | Moderate | 1–10 |
| Power User Loop | TDD + Ralph Loop + Iterative Loops | Solo, long sessions, autonomous iteration | Minimal | 1 |
| Structured Planner | Plan-First + SDD + Context Engineering | Architecture-minded, medium codebase, mixed teams | Light | 1–5 |
Want the full picture?
The guide covers all 20 methodologies in depth, with setup instructions, CLAUDE.md templates, combination patterns, and tradeoff analysis.