BMad Method v6.12.0MIT licensedFree and open sourceDocsGitHubDiscord
BMad Code
BMad Method

A philosophy of the AI-SDLC

Why the method is shaped the way it is: what the machine is for, what it is not for, and what stays with the person doing the work.

The claim

AI is the facilitator.
The human is the expert.

Some frameworks want to replace the human. BMad believes in expertise and the elevation of the human. AI is an amplifier: it elevates those with the will and the skill to grow, and just as readily amplifies those who are not systems thinkers, mess and all. That is why the method matters.

  1. 1Elevate the expert
  2. 2Encode the judgment
  3. 3Move from in the loop to on the loop
Fig. 1 / The objective under planDrag to rotate
The premise

Sending an agent out to work on its own is a dispatch, not a conversation. Once it is moving it has only the objective and the brief you gave it, in terrain you cannot see and cannot correct from. The further it has to go and the more contested the route, the more planning it takes to arrive.

Mission planning, applied to software delivery

First principle

The spec is the work.

A spec can be generated and handed to a model, and monitors, self-corrections and events that end in a coded PR are all possible. But the creation of the spec, at every altitude, is the most important thing a PM, designer or engineer contributes.

Most of the industry is racing to speed up the build. BMad invests where the leverage is: the thinking before the spec. Planning is said to be slow and expensive, and for throwaway work it is not required, but it costs far less than vibe-coded churn or weeks spent building the wrong thing.

Two leaf skeletons crossing, one dark and one light, meeting at a single point
Two hands on one spec
Cadence

Agile evolved, not abandoned.

We do not throw out twenty years of hard-won practice, or rename it. The epic is the new unit of work. Every epic is its own sprint: it opens with an inception and closes with a retro, plus documentation and refactoring.

What changed

Cycle time collapsed

AI collapsed the cycle. It did not remove the need for alignment at the start or consolidation at the end. The closing refactor keeps the docs and codebase clean so the next epic starts from a solid base.

What went

The two-week sprint, and points

Story points went with it, and the long refinement sessions that produced them. What those sessions really produced was shared understanding, and the spec carries that now. One judgment survives, and one person can make it at inception: how much human the item needs.

What arrived

Effort became measurable

Tokens, wall-clock, retries and every human intervention are recorded against the item. Estimating forward was only ever necessary while measuring was too expensive to do. An item that runs far past expectation is not a bad estimate. It is a gap in the brief.

Adoption and choice

The method meets you where you are.

There is a staged adoption curve, from assisted individuals to an on-the-loop organization, and the method scales along it. Not everything runs through the full flow: large work gets analyzed and planned, small bug tickets go straight to build. The rigour should match the work.

Any front door

The PRD is not the only way in

The high-altitude spec is the plan and contract for its altitude, and it takes any input. If a brief is enough, use the brief. Start from a meeting transcript, from design thinking, from a winning idea pulled out of a brainstorm. Or feed several in at once.

brief · transcript · UX · research · many at once
Composable

A platform, not a fixed pipeline

A call becomes a distillation, which becomes tickets, which fire autonomous skills, which leave an implemented ticket and a PR waiting for review. That is possible because the pipeline is configurable where you need it to be.

Mechanism

How the method actually works.

Three deliberate choices, each unconventional, each made because of how models behave rather than how documentation reads.

Skills

Compound skills, shared scripts

Fewer, more powerful skills instead of dozens of small ones. Less overhead polluting the context, fewer misfires where the model loads the wrong skill at the wrong time, and progressive disclosure inside each skill so depth is there when the work calls for it.

Personas

Agents that compound with the skills

Each persona offers more than the individual skills alone. They carry expertise in their field plus an understanding of the method itself, and like every skill they are fully customizable. They are how the facilitation actually happens.

Tickets

Built on research, not vibes

The ticketing process comes from rigorous research into what content a coding agent needs and in what format, not one person's feel, with clear guidance on which documents a model should see for planning versus coding.

Autonomy

In the loop where it matters. On the loop from spec to production.

The two are not a spectrum to pick a point on. They are different jobs, and the method is explicit about which is which.

In the loop

Where judgment is the work

Analysis stays human. Knowing what to build, when, and why, and gauging a prototype, are not tasks to hand off.

On the loop

From spec to production

Assign the spec to the machine, track progress, step in when needed. As a team matures, handing a ticket over gets easier and faster.

Measured

Evidence, not impression

The more you hand over, the less your instinct is worth. Autonomy should be earned against what shipped, what held and what had to be done twice.

Teams

The pod of four.

The roles of PM and engineer have already evolved; structure, staffing and hiring follow. One PM and EM can cover many pods. In every pod at least one person thinks like product and one is a real mentor and AI enabler, emergent and verified rather than titled.

This is a transition for the engineers already on the team, not a re-titling. Teams whose PM specs every acceptance criterion have the harder path. Often it is the org design, not the engineers, that blocks adoption.

Freedom

No lock-in, and never was.

BMad has never been model- or harness-specific. The easy path was to build for one vendor; history keeps showing why we did not. Lock-in creates friction exactly when you need to change, and takes away the choice of the right tool at the right time.

Your modules

Your standards, injected

The module system lets an organization decide who gets which tools, and inject its own modules, agents, standards and knowledge. Favourite skills from elsewhere come in through the same structure and can join the help system, so curation is preserved rather than piled on.

Not absence

Freedom is not the absence of benefit

Building inside the ecosystem gives you agents that understand the relationships between items and suggest what to do next. Customization is standardized across it, and skills know how to operate together. All of it configurable.

Culture

The method that elevates the individual is the same one that trains the org.

Adoption runs on people. Create champions, and build an environment of training and collaboration where the whole team engages the work together and skills spread. The specialized personas carry this too: with their domain knowledge and understanding of the method, they act as coaches inside the day-to-day work.

The method

This is what the product is built to capture.

The philosophy is the argument. The method is how it is practised, and it installs into your repository today.