ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity

docs: remove phase-4 agent persona references 

Follow-up to the agent persona deletion in the parent branch.
Update 11 English doc files to remove references to deleted agents
(dev/Amelia, pm/John, qa/Quinn, sm/Bob, quick-flow-solo-dev/Barry,
bmad-master) and replace with workflow skill equivalents.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Alex Verkhovsky 2026-03-15 20:36:36 -06:00
parent b5c4c99972
commit ebefd5e2f1
11 changed files with 88 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/_STYLE_GUIDE.md
View File

@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
### Can I change my plan later?
Yes. The SM agent has a `bmad-correct-course` workflow for handling scope changes.
Yes. Use `bmad-correct-course` for handling scope changes.
**Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
```

8
docs/explanation/quick-flow.md
View File

@ -36,10 +36,10 @@ Quick Flow has two skills, each backed by a structured workflow. You can run the
### quick-spec: Plan
Run `bmad-quick-spec` and Barry (the Quick Flow agent) walks you through a conversational discovery process:
Run `bmad-quick-spec` and the agent walks you through a conversational discovery process:
1. **Understand** - You describe what you want to build. Barry scans the codebase to ask informed questions, then captures a problem statement, solution approach, and scope boundaries.
2. **Investigate** - Barry reads relevant files, maps code patterns, identifies files to modify, and documents the technical context.
1. **Understand** - You describe what you want to build. The agent scans the codebase to ask informed questions, then captures a problem statement, solution approach, and scope boundaries.
2. **Investigate** - It reads relevant files, maps code patterns, identifies files to modify, and documents the technical context.
3. **Generate** - Produces a complete tech-spec with ordered implementation tasks (specific file paths and actions), acceptance criteria in Given/When/Then format, testing strategy, and dependencies.
4. **Review** - Presents the full spec for your sign-off. You can edit, ask questions, run adversarial review, or refine with advanced elicitation before finalizing.
@ -47,7 +47,7 @@ The output is a `tech-spec-{slug}.md` file saved to your project's implementatio
### quick-dev: Build
Run `bmad-quick-dev` and Barry implements the work. It operates in two modes:
Run `bmad-quick-dev` and the agent implements the work. It operates in two modes:
- **Tech-spec mode** - Point it at a spec file (`quick-dev tech-spec-auth.md`) and it executes every task in order, writes tests, and verifies acceptance criteria.
- **Direct mode** - Give it instructions directly (`quick-dev "refactor the auth middleware"`) and it gathers context, builds a mental plan, and executes.

7
docs/how-to/customize-bmad.md
View File

@ -31,9 +31,8 @@ After installation, find one `.customize.yaml` file per agent in:
```text
_bmad/_config/agents/
├── core-bmad-master.customize.yaml
├── bmm-dev.customize.yaml
├── bmm-pm.customize.yaml
├── bmm-analyst.customize.yaml
├── bmm-architect.customize.yaml
└── ... (one file per installed agent)
```
@ -59,7 +58,7 @@ Change how the agent introduces itself:
```yaml
agent:
metadata:
name: 'Spongebob' # Default: "Amelia"
name: 'Spongebob' # Default: "Mary"
```
**Persona**

2
docs/how-to/established-projects.md
View File

@ -81,7 +81,7 @@ You have two primary options depending on the scope of changes:
| Scope | Recommended Approach |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
| **Small updates or additions** | Use `bmad-quick-flow-solo-dev` to create a tech-spec and implement the change. The full four-phase BMad Method is likely overkill. |
| **Small updates or additions** | Use `bmad-quick-spec` to create a tech-spec, then `bmad-quick-dev` to implement the change. The full four-phase BMad Method is likely overkill. |
| **Major changes or additions** | Start with the BMad Method, applying as much or as little rigor as needed. |
### During PRD Creation

2
docs/how-to/get-answers-about-bmad.md
View File

@ -56,7 +56,7 @@ Use this section when:
| Source | Best For | Examples |
| -------------------- | ----------------------------------------- | ---------------------------- |
| **`_bmad` folder** | How BMad works—agents, workflows, prompts | "What does the PM agent do?" |
| **`_bmad` folder** | How BMad works—agents, workflows, prompts | "What does the Analyst agent do?" |
| **Full GitHub repo** | History, installer, architecture | "What changed in v6?" |
| **`llms-full.txt`** | Quick overview from docs | "Explain BMad's four phases" |

38
docs/how-to/quick-fixes.md
View File

@ -5,7 +5,7 @@ sidebar:
order: 5
---
Use the **DEV agent** directly for bug fixes, refactorings, or small targeted changes that don't require the full BMad Method or Quick Flow.
Use **workflow skills** directly for bug fixes, refactorings, or small targeted changes that don't require the full BMad Method or Quick Flow.
## When to Use This
@ -21,30 +21,30 @@ Use the **DEV agent** directly for bug fixes, refactorings, or small targeted ch
## Choose Your Approach
| Situation | Agent | Why |
| Situation | Workflow skill | Why |
| --- | --- | --- |
| Fix a specific bug or make a small, scoped change | **DEV agent** | Jumps straight into implementation without planning overhead |
| Change touches several files or you want a written plan first | **Quick Flow Solo Dev** | Creates a quick-spec before implementation so the agent stays aligned to your standards |
| Fix a specific bug or make a small, scoped change | `bmad-dev-story` | Jumps straight into implementation without planning overhead |
| Change touches several files or you want a written plan first | `bmad-quick-spec` then `bmad-quick-dev` | Creates a quick-spec before implementation so the AI stays aligned to your standards |
If you are unsure, start with the DEV agent. You can always escalate to Quick Flow if the change grows.
If you are unsure, start with `bmad-dev-story` or describe the change directly to your AI assistant. You can always escalate to Quick Flow if the change grows.
## Steps
### 1. Invoke the DEV Agent
### 1. Invoke a Workflow Skill
Start a **fresh chat** in your AI IDE and invoke the DEV agent skill:
Start a **fresh chat** in your AI IDE and invoke the dev story workflow skill:
```text
bmad-dev
bmad-dev-story
```
This loads the agent's persona and capabilities into the session. If you decide you need Quick Flow instead, invoke the **Quick Flow Solo Dev** agent skill in a fresh chat:
This loads the implementation workflow into the session. If you decide you need a plan first, use Quick Flow in a fresh chat:
```text
bmad-quick-flow-solo-dev
bmad-quick-spec
```
Once the Solo Dev agent is loaded, describe your change and ask it to create a **quick-spec**. The agent drafts a lightweight spec capturing what you want to change and how. After you approve the quick-spec, tell the agent to start the **Quick Flow dev cycle** -- it will implement the change, run tests, and perform a self-review, all guided by the spec you just approved.
The quick-spec workflow walks you through creating a lightweight spec capturing what you want to change and how. After you approve the spec, invoke `bmad-quick-dev` in a fresh chat to implement -- it will execute the change, run tests, and perform a self-review, all guided by the spec you just approved.
:::tip[Fresh Chats]
Always start a new chat session when loading an agent. Reusing a session from a previous workflow can cause context conflicts.
@ -64,18 +64,18 @@ Tell the agent what you need in plain language. Be specific about the problem an
**Dependency update** -- "Upgrade the express dependency to the latest v5 release and fix any breaking changes."
:::
You don't need to provide every detail. The agent will read the relevant source files and ask clarifying questions when needed.
You don't need to provide every detail. The AI will read the relevant source files and ask clarifying questions when needed.
### 3. Let the Agent Work
### 3. Let the AI Work
The agent will:
The AI will:
- Read and analyze the relevant source files
- Propose a solution and explain its reasoning
- Implement the change across the affected files
- Run your project's test suite if one exists
If your project has tests, the agent runs them automatically after making changes and iterates until tests pass. For projects without a test suite, verify the change manually (run the app, hit the endpoint, check the output).
If your project has tests, the AI runs them automatically after making changes and iterates until tests pass. For projects without a test suite, verify the change manually (run the app, hit the endpoint, check the output).
### 4. Review and Verify
@ -83,17 +83,17 @@ Before committing, review what changed:
- Read through the diff to confirm the change matches your intent
- Run the application or tests yourself to double-check
- If something looks wrong, tell the agent what to fix -- it can iterate in the same session
- If something looks wrong, tell the AI what to fix -- it can iterate in the same session
Once satisfied, commit the changes with a clear message describing the fix.
:::caution[If Something Breaks]
If a committed change causes unexpected issues, use `git revert HEAD` to undo the last commit cleanly. Then start a fresh chat with the DEV agent to try a different approach.
If a committed change causes unexpected issues, use `git revert HEAD` to undo the last commit cleanly. Then start a fresh chat to try a different approach.
:::
## Learning Your Codebase
The DEV agent is also useful for exploring unfamiliar code. Load it in a fresh chat and ask questions:
Your AI assistant is also useful for exploring unfamiliar code. Start a fresh chat and ask questions:
:::note[Example Prompts]
"Explain how the authentication system works in this codebase."
@ -103,7 +103,7 @@ The DEV agent is also useful for exploring unfamiliar code. Load it in a fresh c
"What does the `ProcessOrder` function do and what calls it?"
:::
Use the agent to learn about your project, understand how components connect, and explore unfamiliar areas before making changes.
Use your AI assistant to learn about your project, understand how components connect, and explore unfamiliar areas before making changes.
## What You Get

15
docs/reference/agents.md
View File

@ -1,29 +1,24 @@
---
title: Agents
description: Default BMM agents with their skill IDs, menu triggers, and primary workflows
description: Default BMM agents with their skill IDs, menu triggers, and primary workflows (Analyst, Architect, UX Designer, Technical Writer)
sidebar:
order: 2
---
## Default Agents
This page lists the default BMM (Agile suite) agents that install with BMad Method, along with their skill IDs, menu triggers, and primary workflows. Each agent is invoked as a skill.
This page lists the four default BMM (Agile suite) agents that install with BMad Method, along with their skill IDs, menu triggers, and primary workflows. Each agent is invoked as a skill.
## Notes
- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-dev`) is used to invoke the agent.
- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-analyst`) is used to invoke the agent.
- Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
- QA (Quinn) is the lightweight test automation agent in BMM. The full Test Architect (TEA) lives in its own module.
- QA test generation is handled by the `bmad-qa-generate-e2e-tests` workflow skill. The full Test Architect (TEA) lives in its own module.
| Agent | Skill ID | Triggers | Primary workflows |
| --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
| ---------------------- | ------------------ | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
| Analyst (Mary) | `bmad-analyst` | `BP`, `RS`, `CB`, `DP` | Brainstorm Project, Research, Create Brief, Document Project |
| Product Manager (John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course |
| Architect (Winston) | `bmad-architect` | `CA`, `IR` | Create Architecture, Implementation Readiness |
| Scrum Master (Bob) | `bmad-sm` | `SP`, `CS`, `ER`, `CC` | Sprint Planning, Create Story, Epic Retrospective, Correct Course |
| Developer (Amelia) | `bmad-dev` | `DS`, `CR` | Dev Story, Code Review |
| QA Engineer (Quinn) | `bmad-qa` | `QA` | Automate (generate tests for existing features) |
| Quick Flow Solo Dev (Barry) | `bmad-master` | `QS`, `QD`, `CR` | Quick Spec, Quick Dev, Code Review |
| UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
| Technical Writer (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |

12
docs/reference/commands.md
View File

@ -54,12 +54,12 @@ Each skill is a directory containing a `SKILL.md` file. For example, a Claude Co
│ └── SKILL.md
├── bmad-create-prd/
│ └── SKILL.md
├── bmad-dev/
├── bmad-analyst/
│ └── SKILL.md
└── ...
```
The directory name determines the skill name in your IDE. For example, the directory `bmad-dev/` registers the skill `bmad-dev`.
The directory name determines the skill name in your IDE. For example, the directory `bmad-analyst/` registers the skill `bmad-analyst`.
## How to Discover Your Skills
@ -79,10 +79,10 @@ Agent skills load a specialized AI persona with a defined role, communication st
| Example skill | Agent | Role |
| --- | --- | --- |
| `bmad-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
| `bmad-pm` | John (Product Manager) | Creates and validates PRDs |
| `bmad-analyst` | Mary (Analyst) | Brainstorms projects, conducts research, creates briefs |
| `bmad-architect` | Winston (Architect) | Designs system architecture |
| `bmad-sm` | Bob (Scrum Master) | Manages sprints and stories |
| `bmad-ux-designer` | Sally (UX Designer) | Creates UX designs |
| `bmad-tech-writer` | Paige (Technical Writer) | Documents projects, writes guides, generates diagrams |
See [Agents](./agents.md) for the full list of default agents and their triggers.
@ -123,7 +123,7 @@ The core module includes 11 built-in tools — reviews, compression, brainstormi
## Naming Convention
All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-analyst`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
## Troubleshooting

2
docs/reference/modules.md
View File

@ -58,7 +58,7 @@ Structured game development workflows adapted for Unity, Unreal, Godot, and cust
## Test Architect (TEA)
Enterprise-grade test strategy, automation guidance, and release gate decisions through an expert agent and nine structured workflows. TEA goes well beyond the built-in QA agent with risk-based prioritization and requirements traceability.
Enterprise-grade test strategy, automation guidance, and release gate decisions through an expert agent and nine structured workflows. TEA goes well beyond the built-in QA workflow with risk-based prioritization and requirements traceability.
- **Code:** `tea`
- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)

34
docs/reference/testing.md
View File

@ -1,15 +1,15 @@
---
title: Testing Options
description: Comparing the built-in QA agent (Quinn) with the Test Architect (TEA) module for test automation.
description: Comparing the built-in QA workflow with the Test Architect (TEA) module for test automation.
sidebar:
order: 5
---
BMad provides two testing paths: a built-in QA agent for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
BMad provides two testing paths: a built-in QA workflow for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
## Which Should You Use?
| Factor | Quinn (Built-in QA) | TEA Module |
| Factor | Built-in QA | TEA Module |
| --- | --- | --- |
| **Best for** | Small-medium projects, quick coverage | Large projects, regulated or complex domains |
| **Setup** | Nothing to install -- included in BMM | Install separately via `npx bmad-method install` |
@ -18,19 +18,19 @@ BMad provides two testing paths: a built-in QA agent for fast test generation an
| **Strategy** | Happy path + critical edge cases | Risk-based prioritization (P0-P3) |
| **Workflow count** | 1 (Automate) | 9 (design, ATDD, automate, review, trace, and others) |
:::tip[Start with Quinn]
Most projects should start with Quinn. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
:::tip[Start with Built-in QA]
Most projects should start with the built-in QA workflow. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
:::
## Built-in QA Agent (Quinn)
## Built-in QA Workflow
Quinn is the built-in QA agent in the BMM (Agile suite) module. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
The built-in QA workflow is included in the BMM (Agile suite) module. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
**Trigger:** `QA` or `bmad-qa-generate-e2e-tests`
### What Quinn Does
### What the QA Workflow Does
Quinn runs a single workflow (Automate) that walks through five steps:
The QA workflow runs a single workflow (Automate) that walks through five steps:
1. **Detect test framework** -- scans `package.json` and existing test files for your framework (Jest, Vitest, Playwright, Cypress, or any standard runner). If none exists, analyzes the project stack and suggests one.
2. **Identify features** -- asks what to test or auto-discovers features in the codebase.
@ -38,7 +38,7 @@ Quinn runs a single workflow (Automate) that walks through five steps:
4. **Generate E2E tests** -- covers user workflows with semantic locators and visible-outcome assertions.
5. **Run and verify** -- executes the generated tests and fixes failures immediately.
Quinn produces a test summary saved to your project's implementation artifacts folder.
The QA workflow produces a test summary saved to your project's implementation artifacts folder.
### Test Patterns
@ -51,10 +51,10 @@ Generated tests follow a "simple and maintainable" philosophy:
- **Clear descriptions** that read as feature documentation
:::note[Scope]
Quinn generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
The QA workflow generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
:::
### When to Use Quinn
### When to Use Built-in QA
- Quick test coverage for a new or existing feature
- Beginner-friendly test automation without advanced setup
@ -91,16 +91,16 @@ TEA also supports P0-P3 risk-based prioritization and optional integrations with
- Teams that need risk-based test prioritization across many features
- Enterprise environments with formal quality gates before release
- Complex domains where test strategy must be planned before tests are written
- Projects that have outgrown Quinn's single-workflow approach
- Projects that have outgrown the built-in QA workflow
## How Testing Fits into Workflows
Quinn's Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
The QA Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
1. For each story in the epic: implement with Dev (`DS`), then validate with Code Review (`CR`)
2. After the epic is complete: generate tests with Quinn (`QA`) or TEA's Automate workflow
1. For each story in the epic: implement with Dev Story (`DS`), then validate with Code Review (`CR`)
2. After the epic is complete: generate tests with the QA workflow (`QA`) or TEA's Automate workflow
3. Run retrospective (`bmad-retrospective`) to capture lessons learned
Quinn works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
The QA workflow works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
For more on where testing fits in the overall process, see the [Workflow Map](./workflow-map.md).

52
docs/tutorials/getting-started.md
View File

@ -114,7 +114,7 @@ BMad-Help will detect what you've completed and recommend exactly what to do nex
:::
:::note[How to Load Agents and Run Workflows]
Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-create-prd`). Your AI tool will recognize the `bmad-*` name and run it — you don't need to load agents separately. You can also invoke an agent skill directly for general conversation (e.g., `bmad-pm` for the PM agent).
Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-create-prd`). Your AI tool will recognize the `bmad-*` name and run it.
:::
:::caution[Fresh Chats]
@ -141,9 +141,8 @@ All workflows in this phase are optional:
### Phase 2: Planning (Required)
**For BMad Method and Enterprise tracks:**
1. Invoke the **PM agent** (`bmad-pm`) in a new chat
2. Run the `bmad-create-prd` workflow (`bmad-create-prd`)
3. Output: `PRD.md`
1. Run `bmad-create-prd` in a new chat
2. Output: `PRD.md`
**For Quick Flow track:**
- Use the `bmad-quick-spec` workflow (`bmad-quick-spec`) instead of PRD, then skip to implementation
@ -165,9 +164,8 @@ If your project has a user interface, invoke the **UX-Designer agent** (`bmad-ux
Epics and stories are now created *after* architecture. This produces better quality stories because architecture decisions (database, API patterns, tech stack) directly affect how work should be broken down.
:::
1. Invoke the **PM agent** (`bmad-pm`) in a new chat
2. Run `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
3. The workflow uses both PRD and Architecture to create technically-informed stories
1. Run `bmad-create-epics-and-stories` in a new chat
2. The workflow uses both PRD and Architecture to create technically-informed stories
**Implementation Readiness Check** *(Highly Recommended)*
1. Invoke the **Architect agent** (`bmad-architect`) in a new chat
@ -180,19 +178,19 @@ Once planning is complete, move to implementation. **Each workflow should run in
### Initialize Sprint Planning
Invoke the **SM agent** (`bmad-sm`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
Run `bmad-sprint-planning` in a new chat. This creates `sprint-status.yaml` to track all epics and stories.
### The Build Cycle
For each story, repeat this cycle with fresh chats:
| Step | Agent | Workflow | Command | Purpose |
| ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
| 1 | SM | `bmad-create-story` | `bmad-create-story` | Create story file from epic |
| 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | Implement the story |
| 3 | DEV | `bmad-code-review` | `bmad-code-review` | Quality validation *(recommended)* |
| Step | Workflow | Command | Purpose |
| ---- | --------------------- | --------------------- | ---------------------------------- |
| 1 | `bmad-create-story` | `bmad-create-story` | Create story file from epic |
| 2 | `bmad-dev-story` | `bmad-dev-story` | Implement the story |
| 3 | `bmad-code-review` | `bmad-code-review` | Quality validation *(recommended)* |
After completing all stories in an epic, invoke the **SM agent** (`bmad-sm`) and run `bmad-retrospective` (`bmad-retrospective`).
After completing all stories in an epic, run `bmad-retrospective` in a new chat.
## What You've Accomplished
@ -221,18 +219,18 @@ your-project/
## Quick Reference
| Workflow | Command | Agent | Purpose |
| ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
| **`bmad-help`** ⭐ | `bmad-help` | Any | **Your intelligent guide — ask anything!** |
| `bmad-create-prd` | `bmad-create-prd` | PM | Create Product Requirements Document |
| `bmad-create-architecture` | `bmad-create-architecture` | Architect | Create architecture document |
| `bmad-generate-project-context` | `bmad-generate-project-context` | Analyst | Create project context file |
| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | Break down PRD into epics |
| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Validate planning cohesion |
| `bmad-sprint-planning` | `bmad-sprint-planning` | SM | Initialize sprint tracking |
| `bmad-create-story` | `bmad-create-story` | SM | Create a story file |
| `bmad-dev-story` | `bmad-dev-story` | DEV | Implement a story |
| `bmad-code-review` | `bmad-code-review` | DEV | Review implemented code |
| Workflow | Command | Purpose |
| ------------------------------------- | ------------------------------------- | ----------------------------------------------- |
| **`bmad-help`** ⭐ | `bmad-help` | **Your intelligent guide — ask anything!** |
| `bmad-create-prd` | `bmad-create-prd` | Create Product Requirements Document |
| `bmad-create-architecture` | `bmad-create-architecture` | Create architecture document |
| `bmad-generate-project-context` | `bmad-generate-project-context` | Create project context file |
| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | Break down PRD into epics |
| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Validate planning cohesion |
| `bmad-sprint-planning` | `bmad-sprint-planning` | Initialize sprint tracking |
| `bmad-create-story` | `bmad-create-story` | Create a story file |
| `bmad-dev-story` | `bmad-dev-story` | Implement a story |
| `bmad-code-review` | `bmad-code-review` | Review implemented code |
## Common Questions
@ -240,7 +238,7 @@ your-project/
Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-spec to implementation.
**Can I change my plan later?**
Yes. The SM agent has a `bmad-correct-course` workflow (`bmad-correct-course`) for handling scope changes.
Yes. Use `bmad-correct-course` for handling scope changes.
**What if I want to brainstorm first?**
Invoke the Analyst agent (`bmad-analyst`) and run `bmad-brainstorming` (`bmad-brainstorming`) before starting your PRD.