claude-code-ultimate-guide/guide/methodologies.md

Development Methodologies Reference

Confidence: Tier 2 — Validated by multiple production reports and official documentation.

Last updated: January 2026

This is a quick reference for 15 structured development methodologies that have emerged for AI-assisted development in 2025-2026. For hands-on practical workflows, see workflows/.

---

Table of Contents

1. Decision Tree
2. The 15 Methodologies
3. SDD Tools Reference
4. Combination Patterns
5. Sources

---

Decision Tree: What Do You Need?

┌─ "I want quality code" ────────────→ workflows/tdd-with-claude.md
│
├─ "I want to spec before code" ─────→ workflows/spec-first.md
│
├─ "I need to plan architecture" ────→ workflows/plan-driven.md
│
├─ "I'm iterating on something" ─────→ workflows/iterative-refinement.md
│
└─ "I need methodology theory" ──────→ Continue reading below

---

The 15 Methodologies

Organized in a 6-tier pyramid from strategic orchestration down to optimization techniques.

Tier 1: Strategic Orchestration

Name	What	Best For	Claude Fit
BMAD	Multi-agent governance with constitution as guardrail	Enterprise 10+ teams, long-term projects	⭐⭐ Niche but powerful

BMAD (Breakthrough Method for Agile AI-Driven Development) inverts the traditional paradigm: documentation becomes the source of truth, not code. Uses specialized agents (Analyst, PM, Architect, Developer, QA) orchestrated with strict governance.

• Key concept: Constitution.md as strategic guardrail
• When to use: Complex enterprise projects needing governance
• When to avoid: Small teams, MVPs, rapid prototyping

---

Tier 2: Specification & Architecture

Name	What	Best For	Claude Fit
SDD	Specs before code	APIs, contracts	⭐⭐⭐ Core pattern
Doc-Driven	Docs = source of truth	Cross-team alignment	⭐⭐⭐ CLAUDE.md native
Req-Driven	Rich artifact context (20+ artifacts)	Complex requirements	⭐⭐ Heavy setup
DDD	Domain language first	Business logic	⭐⭐ Design-time

SDD (Spec-Driven Development) — Specifications BEFORE code. One well-structured iteration equals 8 unstructured ones. CLAUDE.md IS your spec file.

Doc-Driven Development — Living documentation versioned in git becomes the single source of truth. Changes to specs trigger implementation.

Requirements-Driven Development — Uses CLAUDE.md as comprehensive implementation guide with 20+ structured artifacts.

DDD (Domain-Driven Design) — Aligns software with business language through:

• Ubiquitous Language: Shared vocabulary in code
• Bounded Contexts: Isolated domain boundaries
• Domain Distillation: Core vs Support vs Generic domains

---

Tier 3: Behavior & Acceptance

Name	What	Best For	Claude Fit
BDD	Given-When-Then scenarios	Stakeholder collaboration	⭐⭐⭐ Tests & specs
ATDD	Acceptance criteria first	Compliance, regulated	⭐⭐ Process-heavy
CDD	API contracts as interface	Microservices	⭐⭐⭐ OpenAPI native

BDD (Behavior-Driven Development) — Beyond testing: a collaboration process.

1. Discovery: Involve devs and business experts
2. Formulation: Write Given-When-Then examples
3. Automation: Convert to executable tests (Gherkin/Cucumber)

Feature: Order Management
  Scenario: Cannot buy without stock
    Given product with 0 stock
    When customer attempts purchase
    Then system refuses with error message

ATDD (Acceptance Test-Driven Development) — Acceptance criteria defined BEFORE coding, collaboratively ("Three Amigos": Business, Dev, Test).

CDD (Contract-Driven Development) — API contracts (OpenAPI specs) as executable interface between teams. Patterns: Contract as Test, Contract as Stub.

---

Tier 4: Feature Delivery

Name	What	Best For	Claude Fit
FDD	Feature-by-feature delivery	Large teams 10+	⭐⭐ Structure
Context Eng.	Context as first-class design	Long sessions	⭐⭐⭐ Fundamental

FDD (Feature-Driven Development) — Five processes:

1. Develop Overall Model
2. Build Features List
3. Plan by Feature
4. Design by Feature
5. Build by Feature

Strict iteration: 2 weeks max per feature.

Context Engineering — Treat context as design element:

• Progressive Disclosure: Let agent discover incrementally
• Memory Management: Conversation vs persistent memory
• Dynamic Refresh: Rewrite TODO list before response

---

Tier 5: Implementation

Name	What	Best For	Claude Fit
TDD	Red-Green-Refactor	Quality code	⭐⭐⭐ Core workflow
Eval-Driven	Evals for LLM outputs	AI products	⭐⭐⭐ Agents
Multi-Agent	Orchestrate sub-agents	Complex tasks	⭐⭐⭐ Task tool

TDD (Test-Driven Development) — The classic cycle:

1. Red: Write failing test
2. Green: Minimal code to pass
3. Refactor: Clean up, tests stay green

With Claude: Be explicit. "Write FAILING tests that don't exist yet."

Eval-Driven Development — TDD for LLMs. Test agent behaviors via evals:

• Code-based: output == golden_answer
• LLM-based: Another Claude evaluates
• Human grading: Reference, slow

Multi-Agent Orchestration — From single assistant to orchestrated team:

Meta-Agent (Orchestrator)
├── Analyst (requirements)
├── Architect (design)
├── Developer (code)
└── Reviewer (validation)

---

Tier 6: Optimization

Name	What	Best For	Claude Fit
Iterative Loops	Autonomous refinement	Optimization	⭐⭐⭐ Core
Prompt Engineering	Technique foundation	Everything	⭐⭐⭐ Prerequisite

Iterative Refinement Loops — Autonomous convergence:

1. Execute prompt
2. Observe result
3. If result ≠ "DONE" → refine and repeat

Prompt Engineering — Foundations for ALL Claude usage:

• Zero-Shot Chain of Thought: "Think step by step"
• Few-Shot Learning: 2-3 examples of expected pattern
• Structured Prompts: XML tags for organization
• Position Matters: For long docs, place question at end

---

SDD Tools Reference

Three tools have emerged to formalize Spec-Driven Development:

Tool	Use Case	Official Docs	Claude Integration
Spec Kit	Greenfield, governance	github.blog/spec-kit	/speckit.constitution, /speckit.specify, /speckit.plan
OpenSpec	Brownfield, changes	github.com/Fission-AI/OpenSpec	/openspec:proposal, /openspec:apply, /openspec:archive
Specmatic	API contract testing	specmatic.io	MCP agent available

Spec Kit (Greenfield)

5-phase workflow:

1. Constitution: /speckit.constitution → guardrails
2. Specify: /speckit.specify → requirements
3. Plan: /speckit.plan → architecture
4. Tasks: /speckit.tasks → decomposition
5. Implement: /speckit.implement → code

OpenSpec (Brownfield)

Two-folder architecture:

openspec/
├── specs/      ← Current truth (stable)
└── changes/    ← Proposals (temporary)

Workflow: Proposal → Review → Apply → Archive

Specmatic (API Contracts)

• Contract as Test: Auto-generates 1000s of tests from OpenAPI spec
• Contract as Stub: Mock server for parallel development
• Backward Compatibility: Detects breaking changes

---

Combination Patterns

Recommended stacks by situation:

Situation	Recommended Stack	Notes
Solo MVP	SDD + TDD	Minimal overhead, quality focus
Team 5-10, greenfield	Spec Kit + TDD + BDD	Governance + quality + collaboration
Microservices	CDD + Specmatic	Contract-first, parallel dev
Existing SaaS (100+ features)	OpenSpec + BDD	Change tracking, no spec drift
Enterprise 10+	BMAD + Spec Kit + Specmatic	Full governance + contracts
LLM-native product	Eval-Driven + Multi-Agent	Self-improving systems

---

Quick Reference Table

Methodology	Level	Primary Focus	Team Size	Learning Curve
BMAD	Orchestration	Governance	10+	High
SDD	Specification	Contracts	Any	Medium
Doc-Driven	Specification	Alignment	Any	Low
Req-Driven	Specification	Context	5+	Medium
DDD	Specification	Domain	5+	Very High
BDD	Behavior	Collaboration	5+	Medium
ATDD	Behavior	Compliance	5+	Medium
CDD	Behavior	APIs	5+	Medium
FDD	Delivery	Features	10+	Medium
Context Eng.	Delivery	AI sessions	Any	Low
TDD	Implementation	Quality	Any	Low
Eval-Driven	Implementation	AI outputs	Any	Medium
Multi-Agent	Implementation	Complexity	Any	Medium
Iterative	Optimization	Refinement	Any	Low
Prompt Eng.	Optimization	Foundation	Any	Very Low

---

Sources

Official Documentation (Tier 1)

• Anthropic: Claude Code Best Practices
• Anthropic: Effective Context Engineering for AI Agents
• Anthropic: Demystifying Evals for AI Agents
• GitHub: Spec-Driven Development Toolkit
• Microsoft: Spec-Driven Development with Spec Kit

Methodology References (Tier 2)

SDD & Spec-First

• Martin Fowler: SDD Tools Analysis
• InfoQ: Spec-Driven Development
• Kinde: Beyond TDD - Why SDD is the Next Step
• Tessl.io: Spec-Driven Dev with Claude Code

BMAD

• GMO Recruit: The BMAD Method
• Benny Cheung: BMAD - Reclaiming Control in AI Dev
• GitHub: BMAD-AT-CLAUDE

TDD with AI

• Steve Kinney: TDD with Claude
• Nathan Fox: Taming GenAI Agents
• Alex Op: Custom TDD Workflow Claude Code

BDD & DDD

• Alex Soyes: BDD Behavior-Driven Development
• Alex Soyes: DDD Domain-Driven Design
• Inflectra: Behavior-Driven Development

Context Engineering

• Intuition Labs: What is Context Engineering
• Manus.im: Context Engineering for AI Agents

Eval-Driven & Multi-Agent

• Fireworks AI: Eval-Driven Development with Claude Code
• Brandon Casci: Transform into a Dev Team using Claude Code Agents
• The Unwind AI: Claude Code's Multi-Agent Orchestration

Tools Documentation (Tier 1)

• OpenSpec: github.com/Fission-AI/OpenSpec
• Spec Kit: github.com/github/spec-kit
• Specmatic: specmatic.io
• Specmatic Article: Spec-Driven Development with GitHub Spec Kit and Specmatic MCP

Additional References

• Talent500: Claude Code TDD Guide
• Testlio: Acceptance Test-Driven Development
• Monday.com: Feature-Driven Development
• Paddo.dev: Ralph Wiggum Autonomous Loops
• Walturn: Prompt Engineering for Claude
• AWS: Prompt Engineering with Claude on Bedrock

---

See Also

• workflows/tdd-with-claude.md — Practical TDD guide
• workflows/spec-first.md — Spec-first development
• workflows/plan-driven.md — Using /plan mode
• workflows/iterative-refinement.md — Refinement loops
• ultimate-guide.md#912 — Section 9.12 summary