do-operator
87d3407873
* feat(website): restyle the docs in the bmadcode design system The docs carried a Ghost-blog theme: Inter and Space Grotesk, a #3b82f6 accent, 12px radii, tinted panels and hover lifts. bmadcode.com is built from the foundry ramp on paper, Archivo and IBM Plex Mono, one accent held under ~2% of the page, 2px corners and hairlines. This aligns the two so the method and its documentation read as one thing. Four type registers, and almost nothing else: Instrument Serif for the page masthead, Archivo 600 for headings, Archivo 400 at 17px for prose, and IBM Plex Mono at 11px for labels — spent once per section, never on prose or a table header. The measure comes down to 46rem so a page reads as an article. Also fixes the site title, which was the only place in the repo spelling the brand "BMAD Method"; it now matches the prose, and every page title and share card with it. The four component overrides are the parts CSS could not reach: the mark in its ink tile, the accent eyebrow naming each section, and the dark footer band. The footer renders from TwoColumnContent rather than the Footer slot because Starlight right-aligns the content column (--sl-content-margin-inline: auto 0), so a band in that column never reached the sidebar edge. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * feat(website): inline hand-authored SVG diagrams Diagrams shipped as rasters: build-diagram.png at 488 KB, plus a -fr and a -ko export of the same picture. Every translation meant re-exporting an image, three of the five locales fell back to the English one, and none of them could follow the site's light and dark themes. Diagrams are now hand-authored SVGs carrying geometry and classes only. A rehype plugin inlines them where a page links to one, so a single stylesheet themes every diagram — an <img> is opaque to page CSS, which is the whole reason for inlining. A second diagram written against the same class vocabulary matches the first without any styling work. Labels are translated rather than redrawn: each <text> carries a data-i18n key and the strings live in <name>.labels.json, so one drawing serves every language and a translation cannot drift out of shape. The integration exists because the inlined SVG lands inside Astro's content layer cache, which is keyed on the markdown file. Editing a diagram left the previous drawing on the page, through a build that reported success. It watches the diagram directory in dev and drops the content store when the drawing changes. Diagram.astro is the same behaviour for anywhere that can take a component. The docs are 193 .md files and no .mdx, where components cannot be imported, so the plugin is the path pages actually use. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(build): draw the bmad-build run as a themed SVG Replaces build-diagram.png and its -fr and -ko exports with one drawing shared by all five locales: the actors in a left lane, the spine down the middle, a return channel for BAD_SPEC and INTENT_GAP, and the review lenses in a panel — the layout the original had. Gzipped, the diagram goes from 440 KB to 1 KB, and it now follows the theme. The French labels are in place; the other locales fall back to the English text in the SVG, which is what their pages showed before. The raster files stay for now: walk-through-a-change still uses walkthrough-diagram, and that conversion is a separate change. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(website): let the diagram cache stamp survive a fresh checkout The stamp is written into Astro's cache directory, which does not exist until Astro creates it partway through the build. On a clean clone — CI, every time — the integration threw in astro:config:done and took the build with it. It now creates the directory, and treats any failure as a warning: a cache that cannot be stamped is a slower build, not a broken one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(walkthrough): draw the walkthrough run as a themed SVG Replaces walkthrough-diagram.png and its -fr and -ko exports with one drawing shared by all five locales, keeping the original's layout: the two inputs in a left lane, the five stages down the spine, the notes beside them, the early exit skipping the middle, and the three outcomes along the bottom. The outcome chips introduce a `chip` class in the shared stylesheet, taking the green and amber the asides already use, so a green in a diagram is the same green as a tip. Nothing else about this diagram needed styling: it inherits the vocabulary build-run established. With both diagrams converted, website/public/diagrams is empty and the six raster files are gone. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(plan): fold the remaining diagrams into the themed pipeline planning-skills, development-paths and bmad-delivery-loop were already SVG, but outside the pipeline in three ways: they carried their own palettes, they were served as <img> so page CSS could not reach them, and two of them shipped a -ko twin that duplicated the geometry to translate the labels. Two were drawn dark — navy grounds, white text, cyan strokes — so on a light docs page they sat as dark panels. Their palettes are mapped onto the shared tokens, which flips them correctly in both themes, and their backdrops are dropped: a diagram sits on the page's ground rather than painting its own. The hardcoded typefaces go too, so they inherit Archivo and IBM Plex Mono like everything else. The Korean strings are lifted out of the -ko files into the label files, matched by document order, so all five diagrams are now one drawing per diagram. docs/images is empty. Also fixes the cache guard, which was clearing the wrong store: build writes to the cache directory, dev writes to .astro beside the config, and the stamp was shared between them so whichever ran first consumed the invalidation. It is now per command and build-only — deleting the store under a running dev server leaves the content layer unable to render, so dev needs a restart after a diagram edit instead. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): align the imported diagrams with the shared vocabulary Mapping the old palettes onto the theme tokens made those three diagrams theme-aware, but not part of the system. They still carried 8-16px corners, painted their own canvas panel or background grid, drew every connector in the accent, and left arrowheads baked to a colour of their own — so next to build-run and walkthrough-run they read as imports. They now use the same roles as the two authored diagrams: .node for boxes, .edge for connectors, .head for arrowheads, 2px corners, and no self-painted ground. Accent drops out of all five: it is for the one thing a drawing points at, which here is a single .node.hot on the destination box rather than a green that read as a status. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * chore(docs-site): record hast-util-from-html in the lockfile The dependency was declared in package.json during the move to docs-site but its entry never reached the lockfile's root block, so the two disagreed about what the site depends on. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): land the arrowheads on their targets in build-run Three arrows pointed at glyphs rather than at boxes, and all three fell short: DEFER stopped 10px from the document and aimed at its corner instead of its body, REJECT stopped 27px from the discard glyph, and the result returning to you stopped 21px from the person. The boxes were fine throughout — every arrow into a node already landed within 2px. What the three had in common is that a glyph sits inside a translated group, so eyeballing them against the drawing's coordinates put the endpoints in the wrong place. Measured across all twenty arrowheads in screen space afterwards: the largest remaining gap is 3px. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): move the DEFER label off its own curve, and clear the cache on a dev start too Re-aiming the DEFER arrow at the document glyph swung its curve left, straight through the label that had been sitting clear of the old path. The label moves into the pocket between Present and the curve. Checking it exposed a worse problem: dev was still serving the previous drawing after a restart, so the fix looked like it had not applied. The cache guard had been narrowed to build-only after clearing the store under a live dev server broke rendering — but that failure came from clearing on a mid-session restart, and the watch that caused those is gone. On a cold start, before the content layer loads, clearing is safe in both commands. Confirmed by probe: edit a diagram, restart dev, the edit is served, no errors. So the limitation is now what it was documented to be. Previously an edited diagram needed a full build before dev would show it. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): give every connector an arrowhead, and clear the boxes Three defects in development-paths, all inherited from the import: Connectors were written as two subpaths in one path element. A marker-end lands on the last vertex of a path, so only the second segment ever drew a head — which is why Change—Edit had none and Edit→Verify did. Four connectors are now separate paths, and all twelve carry a head. The two routed connectors ended exactly on the box they point at, so the arrowhead sat on the border. They stop 4px clear. The epic row was 140/130/130 wide with the labels centred on each box. All three are 140 now, evenly spaced, with the connectors and labels following. Band backgrounds were imported as .node, which made every check treat a connector crossing its own band as an error. They are .band now: same appearance, but the drawing says what it means. Also moves the DEFER label in build-run back alongside its curve. The previous fix pushed it clear of the line and lost the association. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): one stroke weight across all five drawings build-run and walkthrough-run carry no inline stroke-width — the stylesheet owns it, at 1.5 for a connector and 1 for a box. The three imported drawings still carried their own: 2, 3, 4 and 2.5, so their lines were twice as heavy as the authored ones. That is also what made the arrowhead into "Build × stories" look wrong. A marker scales with stroke-width by default, so a head defined at 7 units rendered at 21px on a 3px line instead of 10.5px. On a 9px final drop it overshot the corner and sat on the horizontal run above the box. Sixty inline stroke-widths are gone, and the two routed connectors get a longer final drop so the head has room to sit on. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * test(docs-site): cover rehype-inline-diagrams, and fix what it caught Twelve tests alongside the existing plugin suite, against a temporary site root: what gets inlined and what is left alone, label substitution per locale with fallback to the authored English, the accessible name, and the mtime-keyed re-read the dev server depends on. The first run failed on the accessible name, and it was right to. hast camel-cases ARIA attributes, so the guard read `aria-labelledby` and found nothing — meaning every diagram's own <title> was being replaced by the markdown alt text. build-run and walkthrough-run both title themselves with a sentence describing the whole run, and both were announcing a four-word alt instead. Now 119 assertions, and a diagram that names itself keeps its name. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(diagrams): recover the Korean walkthrough labels, and correct the guide Review caught two things. The style guide sent contributors to website/src/diagrams/, the path this branch renamed. A diagram placed there would never be found by the loader or localized. The second is a regression this branch introduced and the PR described wrongly. It claimed the non-English pages "fall back to the English text in the SVG, which is what their pages showed before". That is untrue for four pages: they had localized exports, and replacing those with one drawing plus an English-only label file puts English labels in front of readers who previously had their own language. walkthrough-diagram-ko.svg was an SVG, so its Korean is recoverable and is now the ko-KR label set for walkthrough-run — all 22 keys. The other three were .webp exports, so their text cannot be lifted out: ko-kr build-a-change build-run ko-KR 0/30 keys fr explanation/build build-run fr-FR 13/30 keys fr build/walk-through walkthrough fr-FR 0/22 keys Those need a translator. The 13 French keys are mine and unreviewed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * i18n(diagrams): complete the French and Korean diagram labels Fills the three gaps review found: build-run had no Korean and only 13 of 30 French keys, walkthrough-run had no French. All four sets are now complete. Terms come from the repository rather than fresh coinage. Korean reuses what the -ko diagrams and the Korean pages already established — 의도, 구체화, 계획, 검토, 결과, 사양 — and French follows the vocabulary of docs/fr/explanation/build.md: revue, intention, résultat, implémentation, spécification, and visite guidée from the French walkthrough page. The uppercase edge tokens stay as they are. PATCH, REJECT, BAD_SPEC, INTENT_GAP and DEFER appear in no locale's prose, so they read as protocol constants, the way bmad-build and path:line are already left alone in the Korean set. French runs longer than English and these are fixed-geometry drawings, so both French pages and the Korean one were checked for labels overflowing their box, sitting on a connector, or colliding: none. These are my translations, not a native speaker's. Worth a pass from whoever owns each locale before release. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(docs-site): satisfy the repo's lint and format rules in the new tests The diagram tests used .forEach to walk the hast tree, which this repo's eslint config rejects (unicorn/no-array-for-each), and the file was not Prettier-formatted. CI had been failing on lint since the tests landed. Rewritten as for…of and formatted. Verified against every gate the workflow runs — lint, format:check, test, build — rather than the build alone. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(website): describe the source of the theme without naming a private repo The comments cited the private repository and file paths it was ported from. They point at bmadcode.com instead, which is the public thing a reader can actually check. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * fix(website): keep footer links in the reader's language The footer prefixed only BASE_URL to root-locale paths, so a French or Korean reader following any internal link landed on the English page and lost their language for the rest of the visit. The links now carry the page's locale. Every target exists under every locale — Starlight generates the untranslated ones as fallbacks — so this is safe rather than a trade of one broken link for another: all 36 routes, 6 links across 6 locales, resolve in the built site. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
9.9 KiB
title, description, sidebar
| title | description | sidebar | ||
|---|---|---|---|---|
| Build a Change | Use bmad-build to turn a request, issue, spec, or story into implemented and reviewed code. |
|
The core implementation skill is bmad-build. It takes any expression of
what you want — a sentence, an issue, a spec, or a planned story — investigates
the codebase and upstream context, then plans the change, implements it,
reviews the result, and fixes the bugs it finds. See
how a run works.
Size the Work
Use the smallest amount of BMad that safely fits the change. A typical
session is one goal: about 500 lines of code added or changed (not counting
tests) in a small handful of files. If it fits, give it to bmad-build. If it
doesn't, plan that bigger piece of work first — see
Choose a Planning Path. You
often cannot tell until you try; if you aren't sure, ask bmad-help.
For a trivial edit you are willing to review yourself, skip the process
and ask the agent to make it directly. But if a bug could escape into
production, bmad-build is likely worth it.
Run bmad-build
1. Start a Fresh Chat
Open a fresh chat in your AI IDE. Reusing a session from another workflow can mix contexts and confuse the run.
2. Give It Your Intent
You can describe the change before, with, or after the command. It does not have to be tidy. A ramble, a voice dump, a half-formed thought, an issue link, a file, or a planned story all work — anything the model can turn into a concrete goal.
/bmad-build Fix the login validation bug that allows empty passwords.
/bmad-build Fix https://github.com/org/repo/issues/42.
/bmad-build Implement the intent in
_bmad-output/implementation-artifacts/my-intent.md.
I think the problem is in the auth middleware, it's not checking token expiry.
Let me look at it... yeah, src/auth/middleware.ts line 47 skips
the exp check entirely. /bmad-build
/bmad-build
> What would you like to do?
Refactor UserService to use async/await instead of callbacks.
3. Resolve Intent from Evidence
bmad-build starts from your request and investigates the codebase and any
upstream planning artifacts before deciding whether anything material is still
missing. The input can start rough; clear, evidence-supported requests proceed
without a clarification turn. When something is unclear, it looks for evidence
first — only what the repository and planning context cannot settle becomes an
open question on a finished design, not an interview before work starts.
Answer open questions carefully when they appear. A wrong call there is the most expensive kind of mistake to find later.
4. Approve a Plan When Asked
After investigation, bmad-build routes to the smallest safe path. It reports
three facts about the settled design: intent gaps (things you did not say that you
would notice in the result), irreversible actions, and footprint. A design
clean on all three takes the light path — a minimal spec and implementation in
the same session, reviewed afterwards. Anything flagged gets a full written
plan first, with each intent gap recorded as an open question you answer
before approval.
Approve the plan when it describes the right thing to build. Push back if it does not — fixing the plan is cheaper than fixing the code.
5. Implementation and Review
After that decision, bmad-build implements the change, reviews its own work
with independent reviewers, fixes problems that belong to this change, and
commits locally. This works best on a platform that can spawn subagents, or at
least call another model from the command line and wait for a result.
Review is triage, not a dump of every possible note. Issues that belong to the current change get fixed. Unrelated pre-existing issues get deferred. If the code is wrong because the plan was weak, or the plan is wrong because the goal was wrong, it goes back to that layer and regenerates from there instead of patching only the diff.
For a standalone review — a PR, someone else's change, an extra pass, or a review bot — see Review a Change.
6. Review the Result
When it finishes, bmad-build gives you a short summary and offers the usual
next steps: create a PR, walk through the change, or make another change. For
a guided review of the finished work, see
Walk Through a Change.
- Run the walkthrough or skim the diff to confirm the change matches your intent
- If something looks off, tell the agent what to fix — it can iterate in the same session
Once you are satisfied, ask it to push the commit and create a PR for you.
:::caution[If Something Breaks]
If a pushed change causes unexpected issues, use git revert HEAD to undo the
last commit cleanly. Then start a fresh chat and run bmad-build again with a
different approach.
:::
What You Get
- Modified source files with the change applied
- Passing tests (if your project has a test suite)
- A ready-to-push commit with a conventional commit message
- An implementation record for the run, kept beside the parent spec or story when there is one
For generated API and end-to-end coverage of the finished work, see Test Completed Work.
Deferred Work
Each run stays focused on one goal. If your request contains several independent
goals, or review finds pre-existing issues unrelated to your change,
bmad-build writes them to deferred-work.md in your implementation artifacts
directory instead of trying to do everything at once.
Check that file after a run — it is a backlog of follow-ups. You can feed each
item into a fresh bmad-build run later.
When to Plan First
Add a spec, or PRD, UX, architecture, and story planning, before running
bmad-build when:
- The change affects multiple systems or needs coordinated updates across many files
- You are unsure about the scope and need requirements discovery first
- You need documentation or architectural decisions recorded for the team
- Clarifying the intent keeps surfacing contradictions that one session cannot resolve
Larger work becomes a sequence of one-session changes. That sequence can change
as implementation teaches you more. Parent specs keep the shared goal; story
records carry decisions and completion state; integration checks and
retrospectives cover the combined result. bmad-build handles one unit. It does
not own the backlog, pick the next story, or replace those later checks.
Use bmad-build for foundational, risky, or important stories where your
decisions may set patterns for later work. Once those patterns are stable,
bmad-build-auto can run one unit without waiting for you; see
Autonomous Development Loops.
Implementation Skills
| Skill | Purpose | Produces |
|---|---|---|
bmad-build |
Implement and review one direct intent or planned story with human checkpoints (this page) | Implementation record + code |
bmad-build-auto |
Implement and review one unit unattended for a caller or orchestrator (Autonomous Development Loops) | Implementation record + code + terminal status |
bmad-code-review |
Review any code change with several independent reviewers (Review a Change) | Findings + applied patches |
bmad-correct-course |
Assess the impact of a significant mid-sprint change (Break Work into Stories and Track It) | Updated plan or re-routing |
bmad-retrospective |
Review a completed epic against the evidence it left behind (Finish an Epic) | Retro document, action items, acceptance verdict |
Clear one-session work enters bmad-build directly. A spec-backed epic uses
Story Breakdown to create several units under one SPEC.md; a project adds a
PRD, UX, architecture, epics, readiness results, and sprint tracking before
selecting each unit. bmad-build-auto does not orchestrate those units: an AI
coding session or another orchestrator, such as bmad-loop, dispatches one
worker per unit. See
Autonomous Development Loops for the
worker and orchestration contracts.
Why Does This Take So Long? I Could Plan Mode and Code It in Ten Minutes
You can. The plan-and-implement half of bmad-build usually takes about as
long, and it usually needs a couple fewer turns from you. It then reviews
the result thoroughly, triages the findings, and automatically fixes the
ones worth fixing. "Plan mode and code" does none of this. You have to
invoke a review by hand, then spend time disposing of every finding —
including the noisy and unrelated ones. See
Review a Change.
Human attention is by far the most expensive resource, and the productivity bottleneck in AI-backed software development.
For a throwaway prototype, or a trivial change you will review yourself,
skip the process; see Size the Work. Or tell
bmad-build to take the one-shot route, or to skip review. But if you are
serious about the quality of the product, just let the process run and spend
your attention where it is irreplaceable. That extra time and inference
is worth it.