Getting Started

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

What You’ll Learn

Install and initialize BMad Method for a new project
Choose the right planning track for your project size
Progress through phases from requirements to working code
Use agents and workflows effectively

Understanding BMad

BMad helps you build software through guided workflows with specialized AI agents. The process follows four phases:

Phase	Name	What Happens
1	Analysis	Brainstorming, research, product brief (optional)
2	Planning	Create requirements (PRD or tech-spec)
3	Solutioning	Design architecture (BMad Method/Enterprise only)
4	Implementation	Build epic by epic, story by story

Open the Workflow Map to explore phases, workflows, and context management.

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

Track	Best For	Documents Created
Quick Flow	Bug fixes, simple features, clear scope (1-15 stories)	Tech-spec only
BMad Method	Products, platforms, complex features (10-50+ stories)	PRD + Architecture + UX
Enterprise	Compliance, multi-tenant systems (30+ stories)	PRD + Architecture + Security + DevOps

Installation

Open a terminal in your project directory and run:

npx bmad-method install

When prompted to select modules, choose BMad Method.

The installer creates two folders:

_bmad/ — agents, workflows, tasks, and configuration
_bmad-output/ — empty for now, but this is where your artifacts will be saved

Open your AI IDE in the project folder. Run the help workflow (/bmad-help on most platforms) to see what to do next — it detects what you’ve completed and recommends the next step.

Step 1: Create Your Plan

Work through phases 1-3. Use fresh chats for each workflow.

Phase 1: Analysis (Optional)

All workflows in this phase are optional:

brainstorming — Guided ideation
research — Market and technical research
create-product-brief — Recommended foundation document

Phase 2: Planning (Required)

For BMad Method and Enterprise tracks:

Load the PM agent in a new chat
Run the prd workflow
Output: PRD.md

For Quick Flow track:

Use the quick-spec workflow instead of PRD, then skip to implementation

Phase 3: Solutioning (BMad Method/Enterprise)

Create Architecture

Load the Architect agent in a new chat
Run create-architecture
Output: Architecture document with technical decisions

Create Epics and Stories

Load the PM agent in a new chat
Run create-epics-and-stories
The workflow uses both PRD and Architecture to create technically-informed stories

Implementation Readiness Check (Highly Recommended)

Load the Architect agent in a new chat
Run check-implementation-readiness
Validates cohesion across all planning documents

Step 2: Build Your Project

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

Initialize Sprint Planning

Load the SM agent and run sprint-planning. This creates sprint-status.yaml to track all epics and stories.

The Build Cycle

For each story, repeat this cycle with fresh chats:

Step	Agent	Workflow	Purpose
1	SM	`create-story`	Create story file from epic
2	DEV	`dev-story`	Implement the story
3	DEV	`code-review`	Quality validation (recommended)

After completing all stories in an epic, load the SM agent and run retrospective.

What You’ve Accomplished

You’ve learned the foundation of building with BMad:

Installed BMad and configured it for your IDE
Initialized a project with your chosen planning track
Created planning documents (PRD, Architecture, Epics & Stories)
Understood the build cycle for implementation

Your project now has:

your-project/
├── _bmad/                         # BMad configuration
├── _bmad-output/
│   ├── PRD.md                     # Your requirements document
│   ├── architecture.md            # Technical decisions
│   ├── epics/                     # Epic and story files
│   └── sprint-status.yaml         # Sprint tracking
└── ...

Quick Reference

Workflow	Agent	Purpose
`help`	Any	Get guidance on what to do next
`prd`	PM	Create Product Requirements Document
`create-architecture`	Architect	Create architecture document
`create-epics-and-stories`	PM	Break down PRD into epics
`check-implementation-readiness`	Architect	Validate planning cohesion
`sprint-planning`	SM	Initialize sprint tracking
`create-story`	SM	Create a story file
`dev-story`	DEV	Implement a story
`code-review`	DEV	Review implemented code

Common Questions

Do I always need architecture? Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-spec to implementation.

Can I change my plan later? Yes. The SM agent has a correct-course workflow for handling scope changes.

What if I want to brainstorm first? Load the Analyst agent and run brainstorming before starting your PRD.

Do I need to follow a strict order? Not strictly. Once you learn the flow, you can run workflows directly using the Quick Reference above.

Getting Help

During workflows — Agents guide you with questions and explanations
Community — Discord (#bmad-method-help, #report-bugs-and-issues)
Stuck? — Run help to see what to do next

Key Takeaways

Ready to start? Install BMad and let the agents guide you through your first project.