Skip to main content

​
Getting Started with BMad Method

Build software faster using AI-powered workflows with specialized agents that guide you through planning, architecture, and implementation.

​
What You’ll Learn

1

Install and initialize BMad Method

Set up BMad for your project and understand the core framework structure
2

Meet BMad-Help

Your intelligent guide that knows what to do next at every stage
3

Choose your planning track

Select the right approach based on your project’s complexity
4

Create your plan

Progress through Analysis, Planning, and Solutioning phases
5

Build your project

Implement epic by epic, story by story with AI agent guidance

​
Prerequisites

Before you begin, make sure you have:

Node.js 20+

Required for the BMad Method installer

Git

Recommended for version control throughout development

AI-powered IDE

Claude Code, Cursor, or similar tool with agent support

A project idea

Even a simple one works great for learning
The Easiest Path:
  1. Install → npx bmad-method install
  2. Ask → /bmad-help what should I do first?
  3. Build → Let BMad-Help guide you workflow by workflow

​
Understanding BMad Method

BMad helps you build software through guided workflows with specialized AI agents. The process follows four phases:
PhaseNameWhat Happens
1AnalysisBrainstorming, research, product brief (optional)
2PlanningCreate requirements (PRD or tech-spec)
3SolutioningDesign architecture (BMad Method/Enterprise only)
4ImplementationBuild epic by epic, story by story

Explore the Full Workflow Map

See all available workflows, phases, and context management strategies

​
Planning Tracks

Based on your project’s complexity, BMad offers three planning tracks:

Quick Flow

Best for: Bug fixes, simple features, clear scope (1-15 stories)Documents: Tech-spec only

BMad Method

Best for: Products, platforms, complex features (10-50+ stories)Documents: PRD + Architecture + UX

Enterprise

Best for: Compliance, multi-tenant systems (30+ stories)Documents: PRD + Architecture + Security + DevOps
Story counts are guidance, not definitions. Choose your track based on planning needs, not story math.

​
Step 1: Installation

Open a terminal in your project directory and run: 
npx bmad-method install
When prompted to select modules, choose BMad Method for the full experience.
If you’re getting an outdated version, specify the version explicitly:
npx [email protected] install
For automated environments, use the non-interactive mode:
npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
See Non-Interactive Installation Guide for all options.

​
What Gets Installed

The installer creates two folders: 
your-project/
├── _bmad/
│   ├── bmm/
│   │   ├── agents/          # Agent definitions (PM, Dev, Architect, etc.)
│   │   ├── workflows/       # All workflow instructions
│   │   └── config.yaml      # Module configuration
│   └── core/
│       └── tasks/           # Core workflow engine
└── _bmad-output/            # Your artifacts will be saved here
  • _bmad/ — Agents, workflows, tasks, and configuration
  • _bmad-output/ — Empty for now, but this is where your artifacts will be saved

​
Step 2: Meet BMad-Help

BMad-Help is the fastest way to get started with BMad. You don’t need to memorize workflows or phases — just ask! Open your AI IDE in the project folder and run: 
/bmad-help
BMad-Help will:
  • Inspect your project to see what’s already been done
  • Show your options based on which modules you have installed
  • Recommend what’s next — including the first required task
  • Answer questions like “I have a SaaS idea, where do I start?”
/bmad-help
BMad-Help automatically runs at the end of every workflow to tell you exactly what to do next. No guessing, no searching docs — just clear guidance.

​
Step 3: Create Your Plan

Work through phases 1-3 to create comprehensive planning documents. Use fresh chats for each workflow to prevent context limitations.
Always start a fresh chat for each workflow. This prevents context overflow and ensures optimal agent performance.

​
Phase 1: Analysis (Optional)

All workflows in this phase are optional but recommended for larger projects:

Brainstorming

Run /bmad-brainstorming with the Analyst agent (/bmad-agent-bmm-analyst)Purpose: Guided ideation and exploration of your project concept

Research

Run market, domain, or technical research workflows:
  • /bmad-bmm-market-research — Market analysis and competitive landscape
  • /bmad-bmm-domain-research — Industry domain deep dive
  • /bmad-bmm-technical-research — Technical feasibility exploration

Product Brief

Run /bmad-bmm-create-product-brief to create a foundation documentRecommended: This brief becomes valuable context for your PRD

​
Phase 2: Planning (Required)

For comprehensive projects, create a full PRD:
1

Load the PM Agent

Start a new chat and run:
/bmad-agent-bmm-pm
2

Create your PRD

Run the PRD workflow:
/bmad-bmm-create-prd
The PM agent (John) will guide you through a structured interview process to create a comprehensive Product Requirements Document.
3

Review output

Your PRD will be saved to:
_bmad-output/planning-artifacts/PRD.md
If your project has a user interface:
  1. Load the UX Designer agent (/bmad-agent-bmm-ux-designer)
  2. Run the UX design workflow (/bmad-bmm-create-ux-design)
  3. Output: Comprehensive UX design document with user journeys, component strategy, and design patterns
Project Context (Optional but Recommended)Consider creating project-context.md to document your technical preferences and implementation rules. This ensures all AI agents follow your conventions throughout the project.Create it manually at _bmad-output/project-context.md or generate it after architecture using /bmad-bmm-generate-project-context.Learn more about Project Context

​
Phase 3: Solutioning (BMad Method / Enterprise)

Quick Flow users skip this phase and proceed directly to implementation.
1

Create Architecture

  1. Start a new chat (fresh context)
  2. Load the Architect agent: /bmad-agent-bmm-architect
  3. Run the architecture workflow: /bmad-bmm-create-architecture
The Architect agent (Winston) will guide you through:
  • Technical stack decisions
  • System architecture patterns
  • Database design
  • API structure
  • Security considerations
Output: _bmad-output/planning-artifacts/architecture.md
2

Create Epics and Stories

V6 Improvement: Epics and stories are now created after architecture. This produces better quality stories because architecture decisions directly affect how work should be broken down.
  1. Start a new chat
  2. Load the PM agent: /bmad-agent-bmm-pm
  3. Run: /bmad-bmm-create-epics-and-stories
The workflow uses both PRD and Architecture to create technically-informed stories.Output: _bmad-output/planning-artifacts/epics.md or sharded epic files
3

Implementation Readiness Check (Highly Recommended)

  1. Start a new chat
  2. Load the Architect agent: /bmad-agent-bmm-architect
  3. Run: /bmad-bmm-check-implementation-readiness
This validates cohesion across all planning documents before you start coding.

​
Step 4: Build Your Project

Once planning is complete, move to implementation. Each workflow should run in a fresh chat.

​
Initialize Sprint Planning

1

Load the Scrum Master Agent

/bmad-agent-bmm-sm
2

Run sprint planning

/bmad-bmm-sprint-planning
This creates sprint-status.yaml to track all epics and stories with their current status.
The sprint status file tracks your progress: 
development_status:
  epic-1: in-progress
  1-1-user-authentication: done
  1-2-account-management: in-progress
  1-3-profile-settings: backlog
  epic-1-retrospective: optional
  epic-2: backlog
  # ... more epics and stories

​
The Build Cycle

For each story, repeat this cycle with fresh chats:

Create Story

Agent: Scrum Master (Bob)
/bmad-agent-bmm-sm
/bmad-bmm-create-story
Creates a comprehensive story file with:
  • User story and acceptance criteria
  • Detailed tasks and subtasks
  • Dev notes with architecture requirements
  • Previous learnings from completed stories
  • Latest technical specifications
Output: _bmad-output/implementation-artifacts/1-2-account-management.md

Develop Story

Agent: Developer (Amelia)
/bmad-agent-bmm-dev
/bmad-bmm-dev-story
The Dev agent will:
  • Load the story and all context
  • Follow red-green-refactor TDD cycle
  • Implement each task/subtask sequentially
  • Write comprehensive tests
  • Update the story file with progress
  • Mark story as “review” when complete
The agent executes continuously until all tasks are complete.

Code Review (Recommended)

Agent: Developer (Amelia) — use a different LLM if possible
/bmad-agent-bmm-dev
/bmad-bmm-code-review
For best results, run code review using a different LLM than the one that implemented the story. This provides fresh perspective.
Reviews:
  • Code quality and patterns
  • Test coverage
  • Architecture compliance
  • Security considerations
  • Performance implications

​
Complete an Epic

After completing all stories in an epic:
1

Run Retrospective

Load the SM agent and run:
/bmad-agent-bmm-sm
/bmad-bmm-retrospective
This launches Party Mode where multiple agent personas collaborate in one session to review:
  • What went well
  • What could be improved
  • Lessons learned
  • Action items for next epic

​
What You’ve Accomplished

You’ve learned the foundation of building with BMad:
Installed BMad and configured it for your IDE
Used BMad-Help as your intelligent guide
Created planning documents (PRD, Architecture, Epics & Stories)
Understood the implementation build cycle
Built stories with AI agents and TDD workflows
Your project now has: 
your-project/
├── _bmad/                                   # BMad configuration
├── _bmad-output/
│   ├── planning-artifacts/
│   │   ├── PRD.md                           # Your requirements document
│   │   ├── architecture.md                  # Technical decisions
│   │   └── epics/                           # Epic and story definitions
│   ├── implementation-artifacts/
│   │   ├── sprint-status.yaml               # Sprint tracking
│   │   └── 1-1-user-auth.md                 # Story files
│   └── project-context.md                   # Implementation rules (optional)
├── src/                                     # Your source code
└── tests/                                   # Your tests

​
Quick Reference

Key workflows and their commands:
WorkflowCommandAgentPurpose
Help ⭐/bmad-helpAnyYour intelligent guide
Create PRD/bmad-bmm-create-prdPM (John)Product Requirements Document
UX Design/bmad-bmm-create-ux-designUX Designer (Sally)User experience design
Architecture/bmad-bmm-create-architectureArchitect (Winston)Technical architecture
Epics & Stories/bmad-bmm-create-epics-and-storiesPM (John)Break down PRD into work items
Project Context/bmad-bmm-generate-project-contextAnalyst (Mary)Implementation conventions
Sprint Planning/bmad-bmm-sprint-planningScrum Master (Bob)Initialize sprint tracking
Create Story/bmad-bmm-create-storyScrum Master (Bob)Prepare story for dev
Develop Story/bmad-bmm-dev-storyDeveloper (Amelia)Implement story with TDD
Code Review/bmad-bmm-code-reviewDeveloper (Amelia)Review code quality
Retrospective/bmad-bmm-retrospectiveScrum Master (Bob)Epic completion review

​
Common Questions

Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-spec directly to implementation.
Yes! The SM agent has a correct-course workflow (/bmad-bmm-correct-course) for handling scope changes during implementation.
Load the Analyst agent (/bmad-agent-bmm-analyst) and run brainstorming (/bmad-brainstorming) before starting your PRD.
Not strictly. Once you learn the flow, you can run workflows directly. BMad-Help will always tell you what’s recommended vs. required.
Running a workflow command automatically loads the appropriate agent. You can also load an agent directly for general conversation (e.g., /bmad-agent-bmm-pm for the PM agent).
Party Mode brings multiple agent personas into one session to collaborate and discuss. It’s used in the retrospective workflow where agents like PM, Developer, and Architect all participate in the review.

​
Getting Help

First Stop: BMad-HelpRun /bmad-help anytime — it’s the fastest way to get unstuck. Ask it anything:
  • “What should I do after installing?”
  • “I’m stuck on workflow X”
  • “What are my options for Y?”
  • “Show me what’s been done so far”

Discord Community

Get help in #bmad-method-help and #report-bugs-and-issues channels

GitHub Issues

Report bugs and request features

Documentation

Explore comprehensive guides and reference materials

YouTube Channel

Watch tutorials and master classes

​
Key Takeaways

Start with /bmad-help

Your intelligent guide that knows your project and options

Always use fresh chats

Start a new chat for each workflow to avoid context limitations

Track matters

Choose Quick Flow for simple tasks, BMad Method for products, Enterprise for complex systems

BMad-Help runs automatically

Every workflow ends with guidance on what’s next

​
Next Steps

Create Your First Project

Follow a complete walkthrough from idea to implementation

Working with Agents

Deep dive into agent personas, workflows, and collaboration

Workflow Map

Explore all available workflows and their relationships

Project Context Guide

Learn how to define implementation conventions
Ready to start? Install BMad, run /bmad-help, and let your intelligent guide lead the way.

Build docs developers (and LLMs) love

Get started for freeTalk to us