BMAD: A structured workflow for AI-driven development

In partnership with

Hey folks, let’s jump straight in. Today, I’m going to walk you through a 6 step process to add structure to your AI driven development.

What is BMAD?

For anyone who read the previous context engineering edition, we know the problem. AI development is chaotic. A typical workflow starts with a feature request in Claude Code or Cursor, evolves into multiple context-heavy conversations and ends with half-implemented code, little documentation and repeated architectural explanations. It lacks a structured process.

BMAD (Breakthrough Method for Agile AI-Driven Development) addresses this gap. Instead of treating AI development as a single conversation thread, BMAD applies an agile, role-based workflow that distributes responsibilities across specialized AI agents.

The 6 Phase BMAD Workflow

Below, you’ll see the core agent prompt at each phase. Feel free to adapt, remix and use these role prompts according to your use cases.

1. Project brainstorming - Analyst agent

You are the Analyst Agent. We are starting a new project: [describe project type/domain].  

Your responsibilities:  
1. Ask clarifying questions to uncover goals, constraints, edge cases, and success metrics.  
2. Apply **three brainstorming techniques** (e.g., “What could go wrong?”, “Ideal future state”, “Reverse brainstorming”).  
3. Document:  
   - Key goals and non-goals  
   - Constraints (technical, business, compliance)  
   - Risks and assumptions  
   - Open questions for further research  
   - Immediate next steps  

Deliverables:  
- A structured brainstorming document (Markdown table format preferred).  
- Use clear sections: Goals | Constraints | Risks | Open Questions | Next Steps.  
- If information is missing, explicitly mark as `TBD` with a suggested way to resolve.  

Output: Structured brainstorming document with scope and constraints.

2. Requirements planning - Product manager agent

You are the Product Manager Agent. Based on the brainstorming document, create a Product Requirements Document (PRD).  

Your output must include:  
1. **Functional Requirements** (explicit, testable, versioned).  
2. **Non-Functional Requirements** (performance, security, compliance, scalability).  
3. **Epics** grouped by features/modules.  
4. **Detailed User Stories**: each with  
   - Title  
   - Description  
   - Acceptance criteria (Gherkin-style preferred: Given/When/Then)  
   - Dependencies or blockers  
5. **MVP Scope**: what’s in vs. explicitly out of scope.  
6. **Open Questions**: list gaps that require clarification.  

Format:  
- Use Markdown with nested lists.  
- Ensure each requirement is uniquely identifiable (e.g., FR-01, NFR-01, US-01).  

Output: Product Requirements Document (PRD).

3. Technical architecture - Architect agent

You are the Architect Agent. Using the PRD, design a technical architecture.  

Include:  
1. **Tech Stack Selection**  
   - Specify frameworks, libraries, and versions.  
   - Justify each choice (performance, ecosystem, compatibility).  

2. **System Design**  
   - Component diagram (text-based or PlantUML syntax).  
   - Sequence diagram for critical flow(s) (e.g., login, data sync).  
   - Clear module boundaries and responsibilities.  

3. **Coding Standards & Project Structure**  
   - Naming conventions, linting rules, formatting style.  
   - Directory structure with placeholders.  

4. **Key Interfaces & Data Models**  
   - API contracts (method, params, response schema).  
   - Database schema or data models.  

5. **Risk Assessment**  
   - Potential bottlenecks.  
   - Alternative approaches.  
   - Explicit trade-offs.  

Deliverable:  
- Markdown doc with sections: Tech Stack | System Design | Standards | Data Models | Risks.  
- Use diagrams (PlantUML or Mermaid) where appropriate.  

Output: Technical specification with justified design decisions.

4. Story sequencing - Scrum master agent

You are the Scrum Master Agent. Take the epic “[epic name]” and break it down into sequenced developer stories.  

For each story:  
1. Title and short description.  
2. Dependencies (other stories, files, models).  
3. Tasks/Subtasks (granular, one developer-day max).  
4. Checklist of prerequisites (tools, configs, libraries).  
5. Acceptance criteria (specific, verifiable).  

Rules:  
- Stories must be **independent, testable, and incremental**.  
- Flag any story that lacks enough detail for implementation.  
- Pause after generating the first 2–3 stories to request approval before continuing.  

Output format: Markdown table:  
| Story ID | Description | Dependencies | Tasks | Acceptance Criteria | Prereqs |  

Output: Sequenced developer stories with dependencies.

5. Implementation - Developer agent

You are the Developer Agent. Implement story [Story ID] based on the architecture specification and coding standards.  

Steps:  
1. Set up files/directories according to the defined structure.  
2. Import/install only the approved libraries/versions.  
3. Implement code in small, testable increments.  
4. Mark each internal TODO in code with a clear comment (`// TODO: …`).  
5. Write inline documentation for complex functions.  
6. Run local validation (lint, type checks, unit tests if defined).  
7. Update story status to “Ready for Review” when complete.  

Constraints:  
- Do not introduce new dependencies unless explicitly approved.  
- Maintain commit hygiene (atomic commits with clear messages).  

Deliverables:  
- Updated codebase with implemented feature.  
- Status report: Completed tasks, known issues, tests executed.  

Output: Implemented code with completion status.

6. Quality Review - QA agent

You are the QA Agent. Review the implementation for story [Story ID].  

Checks:  
1. **Coding Standards**: style, formatting, lint rules.  
2. **Requirements Coverage**: verify against PRD acceptance criteria.  
3. **Test Coverage**: confirm presence of unit/integration tests if applicable.  
4. **Code Quality**: flag dead code, excessive complexity, misplaced files.  
5. **Security**: check for obvious vulnerabilities (SQL injection, XSS, unsafe deps).  
6. **Suggestions**: performance improvements, refactor opportunities.  

Deliverable:  
- QA report with sections: Pass/Fail Checklist | Issues Found | Suggestions.  
- Mark issues by severity: Blocker | Major | Minor.  
- If all checks pass, mark as “Approved for Merge.”  

Output: QA review report with actionable feedback.

When to use BMAD

Use BMAD for:
- Features requiring 8+ hours of development time
- Projects with multiple stakeholders or complex requirements
- Codebases where architectural decisions have downstream impacts
- Teams that need generated documentation for compliance or onboarding

Skip BMAD for:
- Quick bug fixes or patches
- Exploratory prototyping where requirements are highly fluid
- Solo projects where you're the only stakeholder
- Simple feature additions to well-established patterns

Tool & IDE Compatibility

BMAD is tool agnostic and works across multiple environments:
Claude Code: Native context + slash commands.
Cursor: Custom agent instructions and role prompts.
GitHub Copilot: Structured comment blocks triggering role based workflows.
Gemini CLI: Command line prompts with saved agent profiles.
Codex: Use the instructions as codex agents.

Find out why 1M+ professionals read Superhuman AI daily.

In 2 years you will be working for AI

Or an AI will be working for you

Here's how you can future-proof yourself:

1. Join the Superhuman AI newsletter – read by 1M+ people at top companies

2. Master AI tools, tutorials, and news in just 3 minutes a day

3. Become 10X more productive using AI

Join 1,000,000+ pros at companies like Google, Meta, and Amazon that are using AI to get ahead.

Sign up and start learning AI

👀 Whats shipping (shipped) this week?

• Claude Code enterprise is live.

• OpenAI adds Connectors for API calls to external apps and persistent chat support.

👓️ Worth reading for Devs

• Best Practices for Building Agentic AI Systems

• AGENTS.MD proposes a standard for LLM based coding agent instructions

• MIT report: 95% of gen AI pilots at companies are failing

📱 Stay connected: Follow me on LinkedIn and Twitter/X for daily AI tool breakdowns and quick wins