What if Claude Code wasn't just a coding assistant, but an entire agile team? An analyst who gathers requirements. A product manager who writes PRDs. An architect who designs systems. A scrum master who breaks work into stories. A developer who implements them. A QA engineer who tests everything.
That's exactly what the BMAD Method does. BMAD — Breakthrough Method for Agile AI-Driven Development — is an open source framework that organizes AI agents into specialized roles that collaborate through a structured four-phase development lifecycle.
It's one of the most ambitious approaches to AI-driven development I've seen. Here's how it works and why it matters.
The Problem BMAD Solves
Every developer who's used AI for coding has hit the same wall: context loss.
You describe a feature. The AI builds it. You describe another feature. The AI builds it — but breaks the first one. By the time you're on feature five, the AI has forgotten the architecture decisions from feature one.
BMAD solves this with a documentation-first approach. Instead of improvising, every AI agent follows documented specifications. The specs are the source of truth, and they persist across conversations and sessions.
The result: AI that follows a plan instead of winging it.
The Four Phases
BMAD organizes development into four sequential phases:
Phase 1: Analysis
A specialized Analyst agent works with you to understand the problem:
- What are the business requirements?
- Who are the users?
- What are the constraints?
- What does success look like?
Output: A structured analysis document that captures everything discovered.
Phase 2: Planning
A Product Manager agent takes the analysis and produces:
- Product Requirements Document (PRD)
- User stories with acceptance criteria
- Feature prioritization
- MVP scope definition
This isn't a vague bullet list. It's a detailed PRD that would pass review at any tech company.
Phase 3: Solutioning
An Architect agent designs the technical solution:
- System architecture with component diagrams
- Technology stack decisions with rationale
- API contracts and data models
- Integration points and dependencies
- Non-functional requirements (performance, security, scalability)
Output: An architecture document that the implementation phase follows exactly.
Phase 4: Implementation
A Scrum Master agent transforms the architecture into hyper-detailed development stories. Each story contains everything a developer (human or AI) needs:
- Exact file paths to create or modify
- Code structure and patterns to follow
- Test cases to write
- Acceptance criteria to verify
Then a Developer agent implements each story. A QA agent verifies the output.
21 Specialized Agents
What makes BMAD remarkable is the depth of specialization. It doesn't use one AI persona for everything — it defines 21 specialized agents, each with:
- A specific role and expertise
- Defined inputs and outputs
- Behavioral guidelines
- Quality standards
Some of the key agents:
| Agent | Role |
|---|---|
| Business Analyst | Requirements gathering, stakeholder interviews |
| Product Manager | PRDs, user stories, prioritization |
| Solution Architect | System design, technology decisions |
| Scrum Master | Story decomposition, sprint planning |
| Full-Stack Developer | Implementation across the stack |
| QA Engineer | Test planning, execution, bug reporting |
| DevOps Engineer | CI/CD, infrastructure, deployment |
| Security Analyst | Threat modeling, security review |
| Technical Writer | Documentation, API docs, user guides |
| UX Designer | User flows, wireframes, design patterns |
Each agent has a system prompt optimized for its role. The Analyst asks different questions than the Architect. The Developer writes different code than the DevOps Engineer. Specialization produces better output.
50+ Guided Workflows
BMAD provides over 50 structured workflows that guide agents through specific tasks:
- Requirements Workshop — Structured session to extract requirements from a vague idea
- Architecture Decision Record — Template for documenting technology choices
- Story Decomposition — Break an epic into implementable stories
- Code Review Checklist — Systematic review covering security, performance, and maintainability
- Incident Postmortem — Structured analysis of production issues
- Sprint Retrospective — Identify improvements across the development process
Each workflow is a step-by-step guide that eliminates the "where do I start?" problem.
Documentation-First: Why It Works
The core insight of BMAD is that AI follows documented specs better than it follows conversational instructions.
When you chat with an AI and say "build me a dashboard," the AI improvises. It makes architecture decisions on the fly. It picks technologies based on whatever it recalls most frequently from training data. The result varies wildly between runs.
When an AI has a detailed PRD and architecture document to follow, hallucinations decrease drastically. The AI has a contract to respect:
- The PRD says the dashboard needs these exact features
- The architecture says to use these exact technologies
- The stories say to create these exact files
No improvisation. No drift. No forgotten requirements.
Subagent Architecture
BMAD leverages Claude Code's subagent capabilities to maximize the context window. Here's the architecture:
Main Agent (orchestrator)
├── Analyst Subagent (requirements phase)
├── PM Subagent (planning phase)
├── Architect Subagent (solutioning phase)
└── Scrum Master Subagent (implementation phase)
├── Developer Subagent (story 1)
├── Developer Subagent (story 2)
├── Developer Subagent (story 3)
└── QA Subagent (verification)
Each subagent gets a fresh 200K token context window. Complex workflows are decomposed into independent subtasks executed by parallel subagents. This means BMAD can handle projects that would overflow a single conversation's context.
BMAD vs. Superpowers
Both BMAD and Superpowers are excellent frameworks, but they serve different purposes:
| Aspect | BMAD | Superpowers |
|---|---|---|
| Focus | Full product lifecycle (ideation to deployment) | Engineering workflow (design to code) |
| Agents | 21 specialized roles | 3 core skills + extensions |
| Best for | Greenfield projects, complete products | Features, fixes, incremental development |
| Methodology | Agile/Scrum with documentation | TDD with brainstorming |
| Complexity | Higher (more phases, more agents) | Lower (simpler to learn) |
| Team simulation | Full agile team | Senior developer pair |
My recommendation: Use BMAD for new projects where you need the full planning lifecycle. Use Superpowers for day-to-day development on existing codebases.
You can even use both — BMAD for the planning phases, then Superpowers for the implementation.
Installation
BMAD works natively with Claude Code:
# Clone the BMAD method
git clone https://github.com/bmad-code-org/BMAD-METHOD.git
# Or use the Claude Code specific port
git clone https://github.com/24601/BMAD-AT-CLAUDE.git
It also supports Cursor, Windsurf, and other AI-based IDEs — the installation auto-detects your platform.
Real Example: Building a SaaS App with BMAD
Here's what a BMAD workflow looks like in practice:
1. Kick off the Analysis phase:
/bmad analyze "I want to build a SaaS tool that helps DevOps teams track infrastructure costs across AWS, Azure, and GCP with AI-powered optimization recommendations"
The Analyst agent asks structured questions: Who are the users? What's the budget? What integrations are required? What's the timeline?
2. The PM agent produces a PRD with:
- User personas (DevOps Lead, FinOps Analyst, Engineering Manager)
- Feature matrix with MoSCoW prioritization
- MVP scope (cloud cost aggregation + basic recommendations)
- User stories with acceptance criteria
3. The Architect designs the system:
- Next.js frontend with Recharts dashboards
- Python FastAPI backend with async cloud API integration
- PostgreSQL for cost data, Redis for caching
- Background jobs for daily cost sync
- Architecture Decision Records for each technology choice
4. The Scrum Master creates stories — each one with exact file paths, code patterns, test cases, and acceptance criteria.
5. Developer agents implement each story. QA agents verify.
The entire process takes a fraction of the time it would take a human team, but produces artifacts that match what a professional team would create.
The Future of AI-Driven Development
BMAD represents a shift in how we think about AI coding tools. The question isn't "can AI write code?" — we know it can. The real question is: "can AI follow a professional software development process?"
BMAD's answer is yes, if you give it the right structure. Not a single super-intelligent agent that does everything, but a team of specialized agents that collaborate through documented artifacts.
This is where AI-driven development is heading: not one model doing everything, but orchestrated multi-agent systems where each agent has a defined role, clear inputs, and measurable outputs.
Resources
- BMAD Method GitHub
- BMAD for Claude Code
- BMAD Documentation
- BMAD Skills for Claude Code
- Superpowers Plugin — complementary framework
I write about AI infrastructure, prompt engineering, and DevOps weekly. Follow on X or LinkedIn. Try my 75 free AI tools.