04What BMAD brings to Claude
Claude knows every language and framework the product needs. It does not know what to build, or when to stop. BMAD supplies the method around it. What a medical device needs on top, I had to add.
Claude can write every layer of a product from clear instructions, so an agent can carry the work from a product brief to a tested story. Left to itself, it also decides what nobody asked it to decide, and decides badly, without saying so (prologue). That needs a method: one that keeps with the team what the product must do, which constraints it meets and which choices its architecture rests on, and gives the AI everything else to work on.
What did the method have to provide?
I set out four needs before I chose one:
- a path from product definition to capabilities, from an intent backed by a business case to requirements, an architecture and pieces of work small enough to build and test, without losing anything on the way, with the discipline Scrum brings;
- a quality system applied at every step, since a medical device needs one and every step that produces something must be held to it;
- repeatable tests, run again the same way on every change;
- room for architecture, recording architectural decisions while leaving them to me.
I looked at GSD, Kiro, Spec Kit, BMAD and a few others, and read their documentation without testing them all. BMAD's documentation was the most convincing, and I tried it on the real project. That is no formal comparison, but the cost of being wrong was low: BMAD is open source and runs on top of Claude, so changing method would have meant changing instructions and templates, and the product's code would have stayed as it was. As the tools stood in mid-2026, BMAD covered the whole life cycle from the first brief, could be extended, which made the QMS plugin possible, kept everything it produced as plain files in version control, and was tied to no editor or vendor.
An agent from day one?
For the product I moved from chat to Claude Code, which works on my workstation: it builds the code, starts and stops the database, application and identity servers, and commits its work. BMAD runs inside it. A reader of GenAI Beyond the Hype may see a contradiction. There I describe four stages for adopting generative AI, Crawl, Walk, Run and Fly, and warn against starting at Fly: handing autonomous agents real work before the organisation has learned to supervise them. An AI developer that reads the code, writes files, runs the tests and commits its changes is exactly such an agent. Did I start at Fly?
No, for two reasons. I started nothing of consequence before the earlier gates were cleared: from 2024 to early 2026, an informed position on generative AI, the experiments of the prologue, with one tool that went into real use helping the CTOs and CIOs of a community I belong to assess candidates' CVs, and then BMAD. Only then did the agent get real work. And software development before release meets the conditions I set for Fly in that same article: actions that can be reversed, errors whose cost is bounded, and outcomes that are cheap to verify. Every change the agent makes is in version control and can be undone. Nothing it writes reaches a patient: nothing has been released to a hospital, and changes go through review, tests and, where the story records one, a live check by me; the gaps are counted below. And each check is far cheaper than producing the work it checks.
What the agent sees is bounded too. It reads and writes the source code, which therefore goes to an external provider, by deliberate decision. It has never seen a real patient record: every piece of data in development and testing is generated for the purpose.
What BMAD brings
BMAD organises the work as a sequence of roles, each played by Claude with its own instructions: analyst, product manager, architect, developer, UX designer, and others. Each role runs workflows, about forty-five in the version I use, and each workflow produces a written artefact that the next one starts from, from the product brief down to each story's Definition of Done.
This is what has come to be called spec-driven development, or SDD: the specification is what you write and maintain, and the code is produced from it. Yet another name ending in DD, and it would not deserve a paragraph if it were only a name. For me it was the means to the end this article is about. I spent my time on what the product must be, which constraints it meets and how it is checked; Claude worked out how to build it, story by story, from specifications precise enough to build from. A specification does not enforce itself, though. My rule against a persistence framework was written in the architecture and still came back three times (chapter 07), which is why the quality system and the build checks sit behind the specs. How SDD, Domain-Driven Design and Scrum fit together when an AI writes the code is the subject of the next article on this site, Scrum, DDD, Claude and BMAD together.
Two parts of that chain made the most difference.
The story carries its own context
Before implementation, a dedicated workflow rewrites each story with everything the developer needs: the relevant requirements, the architecture decisions that apply, the constraints, what earlier stories did. The developer starts every story with a fresh, complete brief, so nothing depends on what a long conversation still remembers.
Review is adversarial, and tireless
Every story's code is meant to be reviewed by three reviewers working in parallel; 23 stories record no review (chapter 01). They find the normal, edge and failure cases, and the fixes and tests come out of their findings.
What reached a person
Of nearly 900 findings, 23 were put to me for a decision, and my answer is written in each story. I also read the findings deferred with a reason; that reading is not recorded. For 121 of the 172 stories, the story records a live check or a confirmation by me. The 62 verification logs record what was checked on which build: 38 a live check, 27 a comparison of the deployed build with the one tested, and some logs record both. Live checks found what the tests and the reviewers missed: the defect of 17 September, and a restriction that passed review, approval and deployment unnoticed. For the other 51 stories, nothing records a check by a person, and I cannot say what it was, so they count as not checked. The records do not say whether I read the code itself. That a person's check is not recorded for every story is a gap, recorded with the missing reviews as open item OPEN-114 in the quality system's register.
What did BMAD leave to the team?
Measured against the four needs, BMAD covered the first well and the third and fourth in part. It had nothing for the second.
| Need | What BMAD gave | What I added |
|---|---|---|
| From product definition to capabilities | Brief, requirements, architecture, readiness check, epics, stories, change proposals | The business case, as a hypothesis to test |
| A quality system applied at every step | Nothing built in | The QMS, the plugin that wires it into the workflows, the Definition of Done (chapters 06 and 07) |
| Repeatable tests | Adversarial review that drives the tests | Build checks: coverage that cannot fall, stricter coverage for safety-related code, every test linked to a requirement |
| Architecture and good practice | An architect role, architecture workflows, review rounds | The decisions themselves: no persistence framework, one database inside the device, the device boundary |
As Figure 4 shows, the chain is the one Scrum asks for, and it has Scrum's gaps too. Scrum is purposefully incomplete: regulatory deliverables and the longer horizon are among the pieces an organisation has to add deliberately, or see them added in the shadows (Scrum in Name Only). BMAD leaves the same two: the quality system, which chapters 06 and 07 are about, and the roadmap and forecast, which chapter 10 is about.
The roles also need watching. Working on the patient search, the developer found that the configuration tool had no way to create a new page. It took this for a missing feature and drafted a new requirement, an epic and a story to build one. Pages are fixed at development time by design; only their content is configurable. I corrected the premise, and the planning was rolled back before any code existed. Each role does its job conscientiously, and that includes widening the scope when nobody tells it where the edges are. Telling it where they are is the team's job.
For your own project
- Write down what the method must provide before you choose one, and add deliberately what it does not cover, as you would for Scrum: for me, a quality system and a roadmap; for you, perhaps security rules, an industry standard or a customer's audit.
- Give an AI agent real work only where its actions can be undone, its errors are bounded and its results are cheap to check, and decide what it may see.
- Tell each role where the edges of the scope are. A diligent agent will otherwise widen it.