bmad-method 6.0.0-alpha.22 → 6.0.0-alpha.23

package/docs/_STYLE_GUIDE.md

@@ -0,0 +1,347 @@
+# Documentation Style Guide
+
+Internal guidelines for maintaining consistent, high-quality documentation across the BMad Method project. This document is not included in the Starlight sidebar — it's for contributors and maintainers, not end users.
+
+## Quick Principles
+
+1. **Clarity over brevity** — Be concise, but never at the cost of understanding
+2. **Consistent structure** — Follow established patterns so readers know what to expect
+3. **Strategic visuals** — Use admonitions, tables, and diagrams purposefully
+4. **Scannable content** — Headers, lists, and callouts help readers find what they need
+
+## Validation Steps
+
+Before submitting documentation changes, run these checks from the repo root:
+
+1. **Fix link format** — Convert relative links (`./`, `../`) to site-relative paths (`/path/`)
+   ```bash
+   npm run docs:fix-links            # Preview changes
+   npm run docs:fix-links -- --write # Apply changes
+   ```
+
+2. **Validate links** — Check all links point to existing files
+   ```bash
+   npm run docs:validate-links            # Preview issues
+   npm run docs:validate-links -- --write # Auto-fix where possible
+   ```
+
+3. **Build the site** — Verify no build errors
+   ```bash
+   npm run docs:build
+   ```
+
+## Tutorial Structure
+
+Every tutorial should follow this structure:
+
+```
+1. Title + Hook (1-2 sentences describing the outcome)
+2. Version/Module Notice (info or warning admonition as appropriate)
+3. What You'll Learn (bullet list of outcomes)
+4. Prerequisites (info admonition)
+5. Quick Path (tip admonition - TL;DR summary)
+6. Understanding [Topic] (context before steps - tables for phases/agents)
+7. Installation (if applicable)
+8. Step 1: [First Major Task]
+9. Step 2: [Second Major Task]
+10. Step 3: [Third Major Task]
+11. What You've Accomplished (summary + folder structure if applicable)
+12. Quick Reference (commands table)
+13. Common Questions (FAQ format)
+14. Getting Help (community links)
+15. Key Takeaways (tip admonition - memorable points)
+```
+
+Not all sections are required for every tutorial, but this is the standard flow.
+
+## Visual Hierarchy
+
+### Avoid
+
+| Pattern | Problem |
+|---------|---------|
+| `---` horizontal rules | Fragment the reading flow |
+| `####` deep headers | Create visual noise |
+| **Important:** bold paragraphs | Blend into body text |
+| Deeply nested lists | Hard to scan |
+| Code blocks for non-code | Confusing semantics |
+
+### Use Instead
+
+| Pattern | When to Use |
+|---------|-------------|
+| White space + section headers | Natural content separation |
+| Bold text within paragraphs | Inline emphasis |
+| Admonitions | Callouts that need attention |
+| Tables | Structured comparisons |
+| Flat lists | Scannable options |
+
+## Admonitions
+
+Use Starlight admonitions strategically:
+
+```md
+:::tip[Title]
+Shortcuts, best practices, "pro tips"
+:::
+
+:::note[Title]
+Context, definitions, examples, prerequisites
+:::
+
+:::caution[Title]
+Caveats, potential issues, things to watch out for
+:::
+
+:::danger[Title]
+Critical warnings only — data loss, security issues
+:::
+```
+
+### Standard Admonition Uses
+
+| Admonition | Standard Use in Tutorials |
+|------------|---------------------------|
+| `:::note[Prerequisites]` | What users need before starting |
+| `:::tip[Quick Path]` | TL;DR summary at top of tutorial |
+| `:::caution[Fresh Chats]` | Context limitation reminders |
+| `:::note[Example]` | Command/response examples |
+| `:::tip[Check Your Status]` | How to verify progress |
+| `:::tip[Remember These]` | Key takeaways at end |
+
+### Admonition Guidelines
+
+- **Always include a title** for tip, info, and warning
+- **Keep content brief** — 1-3 sentences ideal
+- **Don't overuse** — More than 3-4 per major section feels noisy
+- **Don't nest** — Admonitions inside admonitions are hard to read
+
+## Headers
+
+### Budget
+
+- **8-12 `##` sections** for full tutorials following standard structure
+- **2-3 `###` subsections** per `##` section maximum
+- **Avoid `####` entirely** — use bold text or admonitions instead
+
+### Naming
+
+- Use action verbs for steps: "Install BMad", "Create Your Plan"
+- Use nouns for reference sections: "Common Questions", "Quick Reference"
+- Keep headers short and scannable
+
+## Code Blocks
+
+### Do
+
+```md
+```bash
+npx bmad-method install
+```
+```
+
+### Don't
+
+````md
+```
+You: Do something
+Agent: [Response here]
+```
+````
+
+For command/response examples, use an admonition instead:
+
+```md
+:::note[Example]
+Run `workflow-status` and the agent will tell you the next recommended workflow.
+:::
+```
+
+## Tables
+
+Use tables for:
+- Phases and what happens in each
+- Agent roles and when to use them
+- Command references
+- Comparing options
+- Step sequences with multiple attributes
+
+Keep tables simple:
+- 2-4 columns maximum
+- Short cell content
+- Left-align text, right-align numbers
+
+### Standard Tables
+
+**Phases Table:**
+```md
+| Phase | Name | What Happens |
+|-------|------|--------------|
+| 1 | Analysis | Brainstorm, research *(optional)* |
+| 2 | Planning | Requirements — PRD or tech-spec *(required)* |
+```
+
+**Quick Reference Table:**
+```md
+| Command | Agent | Purpose |
+|---------|-------|---------|
+| `*workflow-init` | Analyst | Initialize a new project |
+| `*prd` | PM | Create Product Requirements Document |
+```
+
+**Build Cycle Table:**
+```md
+| Step | Agent | Workflow | Purpose |
+|------|-------|----------|---------|
+| 1 | SM | `create-story` | Create story file from epic |
+| 2 | DEV | `dev-story` | Implement the story |
+```
+
+## Lists
+
+### Flat Lists (Preferred)
+
+```md
+- **Option A** — Description of option A
+- **Option B** — Description of option B
+- **Option C** — Description of option C
+```
+
+### Numbered Steps
+
+```md
+1. Load the **PM agent** in a new chat
+2. Run the PRD workflow: `*prd`
+3. Output: `PRD.md`
+```
+
+### Avoid Deep Nesting
+
+```md
+<!-- Don't do this -->
+1. First step
+   - Sub-step A
+     - Detail 1
+     - Detail 2
+   - Sub-step B
+2. Second step
+```
+
+Instead, break into separate sections or use an admonition for context.
+
+## Links
+
+- Use descriptive link text: `[Tutorial Style Guide](./tutorial-style.md)`
+- Avoid "click here" or bare URLs
+- Prefer relative paths within docs
+
+## Images
+
+- Always include alt text
+- Add a caption in italics below: `*Description of the image.*`
+- Use SVG for diagrams when possible
+- Store in `./images/` relative to the document
+
+## FAQ Sections
+
+Use a TOC with jump links, `###` headers for questions, and direct answers:
+
+```md
+## Questions
+
+- [Do I always need architecture?](#do-i-always-need-architecture)
+- [Can I change my plan later?](#can-i-change-my-plan-later)
+
+### Do I always need architecture?
+
+Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
+
+### Can I change my plan later?
+
+Yes. The SM agent has a `correct-course` workflow for handling scope changes.
+
+**Have a question not answered here?** Please [open an issue](...) or ask in [Discord](...) so we can add it!
+```
+
+### FAQ Guidelines
+
+- **TOC at top** — Jump links under `## Questions` for quick navigation
+- **`###` headers** — Questions are scannable and linkable (no `Q:` prefix)
+- **Direct answers** — No `**A:**` prefix, just the answer
+- **No "Related Documentation"** — Sidebar handles navigation; avoid repetitive links
+- **End with CTA** — "Have a question not answered here?" with issue/Discord links
+
+## Folder Structure Blocks
+
+Show project structure in "What You've Accomplished":
+
+````md
+Your project now has:
+
+```
+your-project/
+├── _bmad/                         # BMad configuration
+├── _bmad-output/
+│   ├── PRD.md                     # Your requirements document
+│   └── bmm-workflow-status.yaml   # Progress tracking
+└── ...
+```
+````
+
+## Example: Before and After
+
+### Before (Noisy)
+
+```md
+---
+
+## Getting Started
+
+### Step 1: Initialize
+
+#### What happens during init?
+
+**Important:** You need to describe your project.
+
+1. Your project goals
+   - What you want to build
+   - Why you're building it
+2. The complexity
+   - Small, medium, or large
+
+---
+```
+
+### After (Clean)
+
+```md
+## Step 1: Initialize Your Project
+
+Load the **Analyst agent** in your IDE, wait for the menu, then run `workflow-init`.
+
+:::note[What Happens]
+You'll describe your project goals and complexity. The workflow then recommends a planning track.
+:::
+```
+
+## Checklist
+
+Before submitting a tutorial:
+
+- [ ] Follows the standard structure
+- [ ] Has version/module notice if applicable
+- [ ] Has "What You'll Learn" section
+- [ ] Has Prerequisites admonition
+- [ ] Has Quick Path TL;DR admonition
+- [ ] No horizontal rules (`---`)
+- [ ] No `####` headers
+- [ ] Admonitions used for callouts (not bold paragraphs)
+- [ ] Tables used for structured data (phases, commands, agents)
+- [ ] Lists are flat (no deep nesting)
+- [ ] Has "What You've Accomplished" section
+- [ ] Has Quick Reference table
+- [ ] Has Common Questions section
+- [ ] Has Getting Help section
+- [ ] Has Key Takeaways admonition
+- [ ] All links use descriptive text
+- [ ] Images have alt text and captions

package/docs/_archive/getting-started-bmadv4.md

@@ -0,0 +1,247 @@
+---
+title: "Getting Started with BMad v4"
+description: Install BMad and create your first planning document
+---
+
+
+Build software faster using AI-powered workflows with specialized agents that guide you through planning, architecture, and implementation.
+
+:::note[Stable Release]
+This tutorial covers BMad v4, the current stable release. For the latest features (with potential breaking changes), see the [BMad v6 Alpha tutorial](./getting-started-bmadv6.md).
+:::
+
+## What You'll Learn
+
+- Install and configure BMad for your IDE
+- Understand how BMad organizes work into phases and agents
+- Initialize a project and choose a planning track
+- Create your first requirements document
+
+:::note[Prerequisites]
+- **Node.js 20+** — Required for the installer
+- **Git** — Recommended for version control
+- **AI-powered IDE** — Claude Code, Cursor, Windsurf, or similar
+- **A project idea** — Even a simple one works for learning
+:::
+
+:::tip[Quick Path]
+**Install** → `npx bmad-method install`
+**Initialize** → Load Analyst agent, run `workflow-init`
+**Plan** → PM creates PRD, Architect creates architecture
+**Build** → SM manages sprints, DEV implements stories
+**Always use fresh chats** for each workflow to avoid context issues.
+:::
+
+## Understanding BMad
+
+BMad helps you build software through guided workflows with specialized AI agents. The process follows four phases:
+
+| Phase | Name | What Happens |
+|-------|------|--------------|
+| 1 | Analysis | Brainstorm, research *(optional)* |
+| 2 | Planning | Requirements — PRD or tech-spec *(required)* |
+| 3 | Solutioning | Architecture, design decisions *(varies by track)* |
+| 4 | Implementation | Build code story by story *(required)* |
+
+Based on your project's complexity, BMad offers three planning tracks:
+
+| Track | Best For | Documents Created |
+|-------|----------|-------------------|
+| **Quick Flow** | Bug fixes, simple features, clear scope | Tech-spec only |
+| **BMad Method** | Products, platforms, complex features | PRD + Architecture + UX |
+| **Enterprise** | Compliance, multi-tenant, enterprise needs | PRD + Architecture + Security + DevOps |
+
+## Installation
+
+Open a terminal in your project directory and run:
+
+```bash
+npx bmad-method install
+```
+
+The interactive installer guides you through setup:
+
+- **Choose Installation Location** — Select current directory (recommended), subdirectory, or custom path
+- **Select Your AI Tool** — Claude Code, Cursor, Windsurf, or other
+- **Choose Modules** — Select **BMM** (BMad Method) for this tutorial
+- **Accept Defaults** — Customize later in `_bmad/[module]/config.yaml`
+
+Verify your installation:
+
+```
+your-project/
+├── _bmad/
+│   ├── bmm/            # Method module
+│   │   ├── agents/     # Agent files
+│   │   ├── workflows/  # Workflow files
+│   │   └── config.yaml # Module config
+│   └── core/           # Core utilities
+├── _bmad-output/       # Generated artifacts (created later)
+└── .claude/            # IDE configuration (if using Claude Code)
+```
+
+:::tip[Troubleshooting]
+Having issues? See [Install BMad](../../how-to/installation/install-bmad.md) for common solutions.
+:::
+
+## Step 1: Initialize Your Project
+
+Load the **Analyst agent** in your IDE:
+- **Claude Code**: Type `/analyst` or load the agent file directly
+- **Cursor/Windsurf**: Open the agent file from `_bmad/bmm/agents/`
+
+Wait for the agent's menu to appear, then run:
+
+```
+Run workflow-init
+```
+
+Or use the shorthand: `*workflow-init`
+
+The workflow asks you to describe:
+- **Your project and goals** — What are you building? What problem does it solve?
+- **Existing codebase** — Is this new (greenfield) or existing code (brownfield)?
+- **Size and complexity** — Roughly how big is this? (adjustable later)
+
+Based on your description, the workflow suggests a planning track. For this tutorial, choose **BMad Method**.
+
+Once you confirm, the workflow creates `bmm-workflow-status.yaml` to track your progress.
+
+:::caution[Fresh Chats]
+Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
+:::
+
+## Step 2: Create Your Plan
+
+With your project initialized, work through the planning phases.
+
+### Phase 1: Analysis (Optional)
+
+If you want to brainstorm or research first:
+- **brainstorm-project** — Guided ideation with the Analyst
+- **research** — Market and technical research
+- **product-brief** — Recommended foundation document
+
+### Phase 2: Planning (Required)
+
+**Start a fresh chat** and load the **PM agent**.
+
+```
+Run prd
+```
+
+Or use shortcuts: `*prd`, select "create-prd" from the menu, or say "Let's create a PRD".
+
+The PM agent guides you through:
+1. **Project overview** — Refine your project description
+2. **Goals and success metrics** — What does success look like?
+3. **User personas** — Who uses this product?
+4. **Functional requirements** — What must the system do?
+5. **Non-functional requirements** — Performance, security, scalability needs
+
+When complete, you'll have `PRD.md` in your `_bmad-output/` folder.
+
+:::note[UX Design (Optional)]
+If your project has a user interface, load the **UX-Designer agent** and run the UX design workflow after creating your PRD.
+:::
+
+### Phase 3: Solutioning (Required for BMad Method)
+
+**Start a fresh chat** and load the **Architect agent**.
+
+```
+Run create-architecture
+```
+
+The architect guides you through technical decisions: tech stack, database design, API patterns, and system structure.
+
+:::tip[Check Your Status]
+Unsure what's next? Load any agent and run `workflow-status`. It tells you the next recommended or required workflow.
+:::
+
+## Step 3: Build Your Project
+
+Once planning is complete, move to implementation.
+
+### Initialize Sprint Planning
+
+Load the **SM agent** and run `sprint-planning`. 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 | Purpose |
+|------|-------|----------|---------|
+| 1 | SM | `create-story` | Create story file from epic |
+| 2 | DEV | `dev-story` | Implement the story |
+| 3 | DEV | `code-review` | Quality validation *(recommended)* |
+
+After completing all stories in an epic, load the **SM agent** and run `retrospective`.
+
+## What You've Accomplished
+
+You've learned the foundation of building with BMad:
+
+- Installed BMad and configured it for your IDE
+- Initialized a project with your chosen planning track
+- Created planning documents (PRD, Architecture)
+- Understood the build cycle for implementation
+
+Your project now has:
+
+```
+your-project/
+├── _bmad/                         # BMad configuration
+├── _bmad-output/
+│   ├── PRD.md                     # Your requirements document
+│   ├── architecture.md            # Technical decisions
+│   └── bmm-workflow-status.yaml   # Progress tracking
+└── ...
+```
+
+## Quick Reference
+
+| Command | Agent | Purpose |
+|---------|-------|---------|
+| `*workflow-init` | Analyst | Initialize a new project |
+| `*workflow-status` | Any | Check progress and next steps |
+| `*prd` | PM | Create Product Requirements Document |
+| `*create-architecture` | Architect | Create architecture document |
+| `*sprint-planning` | SM | Initialize sprint tracking |
+| `*create-story` | SM | Create a story file |
+| `*dev-story` | DEV | Implement a story |
+| `*code-review` | DEV | Review implemented code |
+
+## Common Questions
+
+**Do I need to create a PRD for every project?**
+Only for BMad Method and Enterprise tracks. Quick Flow projects use a simpler tech-spec instead.
+
+**Can I skip Phase 1 (Analysis)?**
+Yes, Phase 1 is optional. If you already know what you're building, start with Phase 2 (Planning).
+
+**What if I want to brainstorm first?**
+Load the Analyst agent and run `*brainstorm-project` before `workflow-init`.
+
+**Why start fresh chats for each workflow?**
+Workflows are context-intensive. Reusing chats can cause the AI to hallucinate or lose track of details. Fresh chats ensure maximum context capacity.
+
+## Getting Help
+
+- **During workflows** — Agents guide you with questions and explanations
+- **Check status** — Run `workflow-status` with any agent
+- **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
+- **Video tutorials** — [BMad Code YouTube](https://www.youtube.com/@BMadCode)
+
+## Key Takeaways
+
+:::tip[Remember These]
+- **Always use fresh chats** — Load agents in new chats for each workflow
+- **Let workflow-status guide you** — Ask any agent for status when unsure
+- **Track matters** — Quick Flow uses tech-spec; Method/Enterprise need PRD and architecture
+- **Tracking is automatic** — Status files update themselves
+- **Agents are flexible** — Use menu numbers, shortcuts (`*prd`), or natural language
+:::
+
+Ready to start? Install BMad, load the Analyst, run `workflow-init`, and let the agents guide you.

package/{website/src/pages → docs}/downloads.md

@@ -1,32 +1,38 @@
-# Downloads
+---
+title: Downloads
+---
 
-Download BMAD Method resources for offline use, AI training, or integration.
+Download BMad Method resources for offline use, AI training, or integration.
+
+## Source Bundles
+
+| File | Description |
+|------|-------------|
+| **[bmad-sources.zip](/downloads/bmad-sources.zip)** | Complete BMad source files |
+| **[bmad-prompts.zip](/downloads/bmad-prompts.zip)** | Agent and workflow prompts only |
 
 ## LLM-Optimized Files
 
 These files are designed for AI consumption - perfect for loading into Claude, ChatGPT, or any LLM context window.
 
-| File                                | Description                         | Use Case                   |
-| ----------------------------------- | ----------------------------------- | -------------------------- |
-| **[llms.txt](/llms.txt)**           | Documentation index with summaries  | Quick overview, navigation |
-| **[llms-full.txt](/llms-full.txt)** | Complete documentation concatenated | Full context loading       |
+| File | Description | Use Case |
+|------|-------------|----------|
+| **[llms.txt](/llms.txt)** | Documentation index with summaries | Quick overview, navigation |
+| **[llms-full.txt](/llms-full.txt)** | Complete documentation concatenated | Full context loading |
 
 ### Using with LLMs
 
 **Claude Projects:**
-
 ```
 Upload llms-full.txt as project knowledge
 ```
 
 **ChatGPT:**
-
 ```
 Paste llms.txt for navigation, or sections from llms-full.txt as needed
 ```
 
 **API Usage:**
-
 ```python
 import requests
 docs = requests.get("https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt").text
@@ -48,7 +54,7 @@ npx bmad-method@alpha install
 
 ## API Access
 
-For programmatic access to BMAD documentation:
+For programmatic access to BMad documentation:
 
 ```bash
 # Get documentation index
@@ -60,7 +66,7 @@ curl https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
 
 ## Contributing
 
-Want to improve BMAD Method? Check out:
+Want to improve BMad Method? Check out:
 
 - [Contributing Guide](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CONTRIBUTING.md)
 - [GitHub Repository](https://github.com/bmad-code-org/BMAD-METHOD)