BMAD 101

BMAD — the Breakthrough Method for Agile AI-Driven Development — is a spec-first way of working with an AI coding agent. Instead of “hey, build me a blog” and hoping, you move through a series of expert roles — analyst, PM, architect, UX, developer — and the AI plays each one with you, producing a documented artifact at every step. The planning is front-loaded so the building stays calm. This page gets you from nothing installed to your first story; it pairs naturally with Claude Code 101, which is the agent that does the building.

I built this site and the handbook you’re reading this way — the full paper trail (brief, PRD, UX, architecture, epics and stories) is public in each repo’s _bmad-output/ folder if you want to see the method in practice before you try it. For the fuller story of what that felt like, see Building in public with BMAD.

1. What you need first

• Node.js 20.12 or newer — the one hard requirement enforced at install.
• Git — used to pull in modules.
• An AI coding agent — Claude Code or Cursor are the common choices. Get that working first; BMAD installs into the tool you already use.

2. Install it into your project

From the root of the project you want to work in:

npx bmad-method install

There’s no global install to manage — you run it per project. The installer is interactive: it asks where to install (defaults to the current directory), which modules you want, and which IDE/agent to wire up (e.g. Claude Code). Accept the defaults your first time. It writes its configuration and the artifacts it generates into the project so everything lives alongside your code and gets committed with it.

To see every supported tool integration before you commit:

npx bmad-method install --list-tools

3. Meet the roles

BMAD gives you a set of named agent personas, each an expert collaborator for one part of the work. You invoke them one at a time:

The magic isn’t any single agent — it’s that each one’s output becomes the context for the next. The analyst’s framing feeds the PM’s requirements; the requirements feed the architect; and so on down to the developer, who finally writes code against a spec that traces all the way back.

4. The flow: plan, then build

BMAD splits work into two big movements — planning (heavy human-AI collaboration) and implementation (the agent executes, one story at a time). In practice it runs in a few phases:

1. Analysis (optional) — brainstorm and research to make sure you’re solving the right problem.
2. Planning — create the PRD, and optionally a UX design. Every feature becomes a numbered requirement you can point at later.
3. Solutioning — design the architecture, then break everything into epics and small, testable stories. Run a readiness check before you build.
4. Implementation — do sprint planning, then loop per story: create the story → implement it → review it, with a retrospective after each epic.

A newcomer path: after install, ask BMAD’s help/guide to inspect your project and recommend the next step. For small, well-understood work there’s a quick track that clarifies, plans, implements, and reviews in a single pass — you don’t need the full ceremony for a bug fix.

Why it’s worth the ceremony

The upfront structure sounds heavy, but it pays for itself — the spec becomes the single source of truth, decisions get captured once and reused everywhere, and constraints quietly make the defaults good. I wrote about the three ways that played out while building this very site in Building in public with BMAD.

Where to go next

BMAD is one concrete way to practice the discipline that AI-Native Engineering is really about — treating the work as an engineering problem with artifacts and traceability, not a pile of clever prompts. And getting a whole team to adopt a method like this is its own change-management challenge.