The complete command and skill reference

This is the inventory: every skill in core and BMM, every default agent trigger, and every skill each official module ships. It is a reference to scan, not a narrative. Deep Recon (bmad-deep-recon, the research skill) is listed here but documented in depth in the existing recon gists (foundation, how-to, complete guide, research reference); this page does not repeat them.

On this page

• How commands work
• Core module (8 tools, always installed)
• BMM workflows by phase
• BMM agent triggers
• Module skills
• Installer and orchestration commands
• Hands-on: a five-command tour on one small feature
• Under Claude Code: how a big skill surface stays cheap

How commands work

There are two ways to start work, and the difference matters:

Every skill uses the bmad- prefix (module skills sometimes add their code, like bmad-cis- or gds-). The installer generates skills from your installed modules, so the canonical list for your machine is always the installed skill directories, not any published list:

find .claude/skills -maxdepth 1 -type d -name 'bmad-*' | sort   # Claude Code
find .agents/skills -maxdepth 1 -type d | sort                  # Cursor / Windsurf

bmad-help reads that installed set and recommends the next step; it is the one command to run whenever you are unsure.

Core module (8 tools, always installed)

The core module is a small set of tools that work in any phase, any module, no agent session required.

The four kernel tools:

The four thinking skills:

Some earlier IDs now forward to these: the three research workflows (bmad-market-research, bmad-domain-research, bmad-technical-research) into bmad-deep-recon; the separate editorial and adversarial review skills into bmad-review. bmad-shard-doc and bmad-index-docs were removed; bmad-spec moved into BMM as a Phase 2 workflow.

BMM workflows by phase

The full four-phase inventory. See the workflow map for what each produces.

BMM agent triggers

Once an agent is loaded, these short codes start its workflows.

Module skills

Installed only when you select the module. Names are exact; descriptions are one line each.

BMad Builder (bmb, v2.1.0)

The meta-module: build your own agents, workflows, and modules.

It also ships sample agents you can study or use (bmad-agent-code-coach, bmad-agent-creative-muse, bmad-agent-diagram-reviewer, bmad-agent-dream-weaver, bmad-agent-sentinel, bmad-excalidraw).

Creative Intelligence Suite (cis, v0.2.1)

Six coaches and four workflows for the fuzzy front end.

Test Architect (tea, v1.19.1)

Murat (bmad-tea), plus nine workflows under bmad-testarch-* (and bmad-teach-me-testing):

Supports P0-P3 risk prioritization and optional Playwright Utils and MCP browser automation.

Game Dev Studio (gds, v0.6.0)

Five agents and 28 workflows; the largest module. Agents: gds-agent-game-architect (Cloud Dragonborn), gds-agent-game-designer (Samus Shepard), gds-agent-game-dev (Link Freeman, also QA and scrum), gds-agent-game-solo-dev (Indie), gds-agent-tech-writer (Paige). Workflows span preproduction (gds-brainstorm-game, gds-create-game-brief, gds-domain-research), design (gds-gdd, gds-create-narrative, gds-prd, gds-ux), technical (gds-game-architecture, gds-create-epics-and-stories, gds-check-implementation-readiness, gds-generate-project-context), production (gds-create-story, gds-dev-story, gds-code-review, gds-investigate, gds-sprint-planning, gds-sprint-status, gds-correct-course, gds-retrospective), a seven-workflow game-test suite (gds-test-design, gds-test-automate, gds-playtest-plan, gds-performance-test, gds-e2e-scaffold, gds-test-framework, gds-test-review), and quick-flow (gds-quick-dev, gds-document-project).

Whiteport Design Studio (wds, v0.4.3)

Three "Norse" agents (wds-agent-saga-analyst Saga, wds-agent-freya-ux Freya, wds-agent-mimir-builder Mimir) driving a numbered pipeline: wds-0-project-setup, wds-0-alignment-signoff, wds-1-project-brief, wds-2-trigger-mapping, wds-3-scenarios, wds-4-ux-design, wds-5-agentic-development, wds-6-asset-generation, wds-7-design-system, wds-8-product-evolution.

BMad Loop (bmad-loop, v0.9.0)

A deterministic Python orchestrator (not an LLM persona) for unattended dev loops. Skills: bmad-loop-setup (install), bmad-loop-resolve (human-in-the-loop escalation), bmad-loop-sweep (triage the deferred-work ledger). It drives the upstream bmad-dev-auto skill from a CLI:

bmad-loop run | resume | attach | status | list | stop | sweep | resolve
             | init | tui | mux | plugin | skill | validate | diagnose
             | decisions | archive | clean | delete | probe-adapter

It requires Python 3.11+, a terminal multiplexer (tmux; psmux on Windows), and a BMAD v6 project on BMAD-METHOD 6.10.0+. Its tmux adapter can drive claude, codex, gemini, copilot, antigravity, or opencode, mixing agents per stage. The end-to-end page walks a run.

Installer and orchestration commands

The npx bmad-method install flags are on the install page; the ones you reach for most:

npx bmad-method install                                   # interactive wizard / update
npx bmad-method install --yes --modules bmm --tools claude-code   # scripted
npx bmad-method install --list-tools                      # supported IDEs
npx bmad-method install --list-options bmm                # every --set key for a module
npx bmad-method install --yes --action update --modules bmm,bmb   # add a module

Hands-on: a five-command tour on one small feature

The command surface reads best as a pipeline: each skill drops a file, and the next skill reads it. Here is one toy feature, saved search filters (name and re-run a search), walked through five skills. Run each in a fresh chat so no step leans on the previous conversation, only on the file it left behind. Nothing below is machine-verified; BMAD and Claude Code are not installed on this box.

1. Ideate. bmad-brainstorming pulls options out of you onto one HTML canvas.

/bmad-brainstorming "saved search filters for our list view"

Illustrative (run it in your own repo; not machine-verified here).

docs/brainstorm.html
  <h2>Saved search filters</h2>
  <li>name + pin a set · share via URL · "recent" auto-list · per-user vs team scope</li>

2. Plan. bmad-prd, Create intent, reads that canvas and writes the PRD.

/bmad-prd    # choose: Create

Illustrative (run it in your own repo; not machine-verified here).

docs/prd.md
  ## FR1  A user can save the current filter set under a name.
  ## FR2  Saved filters appear in a per-user list and re-apply on click.

3. Distill. bmad-spec collapses the PRD into a SPEC.md kernel, the machine contract: five fields.

/bmad-spec

Illustrative (run it in your own repo; not machine-verified here).

SPEC.md
  intent:      persist and re-apply named filter sets, per user
  inputs:      { name, filters[], userId }
  outputs:     SavedFilter record; list endpoint
  behavior:    unique name per user; re-apply sets query state
  acceptance:  save, reload, list shows it, click re-applies

4. Build. bmad-dev-story reads SPEC.md, writes tests first, then the code, and records a story file.

/bmad-dev-story

Illustrative (run it in your own repo; not machine-verified here).

docs/stories/story-1.md   status: Ready for Review
+++ src/filters/saved.ts
+ export function saveFilter(name, filters, userId) { ... }
+++ src/filters/saved.test.ts   (3 passing)

5. Review. bmad-code-review reads the diff and the story and returns a findings list (zero findings is a valid result).

/bmad-code-review

Illustrative (run it in your own repo; not machine-verified here).

[HIGH]  saveFilter: no uniqueness check on (userId, name), SPEC violated
[LOW]   test.ts: missing empty-filters case

Five commands, five files, one chain: brainstorm.html to prd.md to SPEC.md to story plus diff to findings. Each step's input is the last step's output on disk, which is why fresh chats work. Full runs of this shape, end to end, are the next page.

Under Claude Code: how a big skill surface stays cheap

On Claude Code every BMAD skill installs as a slash command, /<skill> (/bmad-help, /bmad-prd, /bmad-dev-story). You start one two ways: type it, or let Claude read the SKILL.md description and pick the match. That is the same split this page draws between a skill and an agent-menu trigger.

Dozens of commands stay affordable because of progressive disclosure. At session start only each skill's name plus description enter context, on the order of 50 tokens each. The full SKILL.md body loads only when the skill is invoked, and then it stays in context for the rest of the session. The whole listing is budget-capped: skillListingBudgetFraction defaults to roughly 1% of the context window, so a large install cannot crowd out your work. Under auto-compaction Claude keeps only about the first 5k tokens of the most recent invocation per skill, under a shared budget; older skills can drop entirely.

Arguments feed a skill by substitution: $ARGUMENTS (everything), $0/$1 (positional), or named $name once you declare arguments: in frontmatter. argument-hint shows in autocomplete, the way a trigger like DS in the table above hints its input.

Author your own one-off command as .claude/commands/<name>.md (the filename becomes the name) or the newer skill form. /help lists everything installed; /skills toggles each one's visibility (full / name-only / off), which mirrors filtering the installed skill directories this page tells you to find. What each skill produces is on the workflow map (page 4).

Net: BMAD's full inventory costs its descriptions, not its bodies, until you run a command.

That is the full working surface for core, BMM, and the official modules. The next page stops listing and starts doing: four complete project runs, from a blank idea to shipped code. 👉