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

package/docs/tutorials/advanced/create-custom-agent.md

@@ -0,0 +1,171 @@
+---
+title: "Create a Custom Agent"
+---
+
+
+Build your own AI agent with a unique personality, specialized commands, and optional persistent memory using the BMad Builder workflow.
+
+:::note[BMB Module]
+This tutorial uses the **BMad Builder (BMB)** module. Make sure you have BMad installed with the BMB module enabled.
+:::
+
+## What You'll Learn
+
+- How to run the `create-agent` workflow
+- Choose between Simple, Expert, and Module agent types
+- Define your agent's persona (role, identity, communication style, principles)
+- Package and install your custom agent
+- Test and iterate on your agent's behavior
+
+:::note[Prerequisites]
+- BMad installed with the BMB module
+- An idea for what you want your agent to do
+- About 15-30 minutes for your first agent
+:::
+
+:::tip[Quick Path]
+Run `create-agent` workflow → Follow the guided steps → Install your agent module → Test and iterate.
+:::
+
+## Understanding Agent Types
+
+Before creating your agent, understand the three types available:
+
+| Type       | Best For                              | Memory     | Complexity |
+| ---------- | ------------------------------------- | ---------- | ---------- |
+| **Simple** | Focused tasks, quick setup            | None       | Low        |
+| **Expert** | Specialized domains, ongoing projects | Persistent | Medium     |
+| **Module** | Building other agents/workflows       | Persistent | High       |
+
+**Simple Agent** - Use when your task is well-defined and focused. Perfect for single-purpose assistants like commit message generators or code reviewers.
+
+**Expert Agent** - Use when your domain requires specialized knowledge or you need memory across sessions. Great for roles like Security Architect or Documentation Lead.
+
+**Module Agent** - Use when your agent builds other agents or needs deep integration with the module system.
+
+## Step 1: Start the Workflow
+
+In your IDE (Claude Code, Cursor, etc.), invoke the create-agent workflow with the agent-builder agent.
+
+The workflow guides you through eight steps:
+
+| Step                        | What You'll Do                               |
+| --------------------------- | -------------------------------------------- |
+| **Brainstorm** *(optional)* | Explore ideas with creative techniques       |
+| **Discovery**               | Define the agent's purpose and goals         |
+| **Type & Metadata**         | Choose Simple or Expert, name your agent     |
+| **Persona**                 | Craft the agent's personality and principles |
+| **Commands**                | Define what the agent can do                 |
+| **Activation**              | Set up autonomous behaviors *(optional)*     |
+| **Build**                   | Generate the agent file                      |
+| **Validation**              | Review and verify everything works           |
+
+:::tip[Workflow Options]
+At each step, the workflow provides options:
+- **[A] Advanced** - Get deeper insights and reasoning
+- **[P] Party** - Get multiple agent perspectives
+- **[C] Continue** - Move to the next step
+:::
+
+## Step 2: Define the Persona
+
+Your agent's personality is defined by four fields:
+
+| Field                   | Purpose        | Example                                                           |
+| ----------------------- | -------------- | ----------------------------------------------------------------- |
+| **Role**                | What they do   | "Senior code reviewer who catches bugs and suggests improvements" |
+| **Identity**            | Who they are   | "Friendly but exacting, believes clean code is a craft"           |
+| **Communication Style** | How they speak | "Direct, constructive, explains the 'why' behind suggestions"     |
+| **Principles**          | Why they act   | "Security first, clarity over cleverness, test what you fix"      |
+
+Keep each field focused on its purpose. The role isn't personality; the identity isn't job description.
+
+:::note[Writing Great Principles]
+The first principle should "activate" the agent's expertise:
+
+- **Weak:** "Be helpful and accurate"
+- **Strong:** "Channel decades of security expertise: threat modeling begins with trust boundaries, never trust client input, defense in depth is non-negotiable"
+:::
+
+## Step 3: Install Your Agent
+
+Once created, package your agent for installation:
+
+```
+my-custom-stuff/
+├── module.yaml          # Contains: unitary: true
+├── agents/
+│   └── {agent-name}/
+│       ├── {agent-name}.agent.yaml
+│       └── _memory/              # Expert agents only
+│           └── {sidecar-folder}/
+└── workflows/           # Optional: custom workflows
+```
+
+Install using the BMad installer, then invoke your new agent in your IDE.
+
+## What You've Accomplished
+
+You've created a custom AI agent with:
+
+- A defined purpose and role in your workflow
+- A unique persona with communication style and principles
+- Custom menu commands for your specific tasks
+- Optional persistent memory for ongoing context
+
+Your project now includes:
+
+```
+_bmad/
+├── _config/
+│   └── agents/
+│       └── {your-agent}/        # Your agent customizations
+└── {module}/
+    └── agents/
+        └── {your-agent}/
+            └── {your-agent}.agent.yaml
+```
+
+## Quick Reference
+
+| Action              | How                                            |
+| ------------------- | ---------------------------------------------- |
+| Start workflow      | `"Run the BMad Builder create-agent workflow"` |
+| Edit agent directly | Modify `{agent-name}.agent.yaml`               |
+| Edit customization  | Modify `_bmad/_config/agents/{agent-name}`     |
+| Rebuild agent       | `npx bmad-method build <agent-name>`           |
+| Study examples      | Check `src/modules/bmb/reference/agents/`      |
+
+## Common Questions
+
+**Should I start with Simple or Expert?**
+Start with Simple for your first agent. You can always upgrade to Expert later if you need persistent memory.
+
+**How do I add more commands later?**
+Edit the agent YAML directly or use the customization file in `_bmad/_config/agents/`. Then rebuild.
+
+**Can I share my agent with others?**
+Yes. Package your agent as a standalone module and share it with your team or the community.
+
+**Where can I see example agents?**
+Study the reference agents in `src/modules/bmb/reference/agents/`:
+- [commit-poet](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/simple-examples/commit-poet.agent.yaml) (Simple)
+- [journal-keeper](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples/journal-keeper) (Expert)
+
+## Getting Help
+
+- **[Discord Community](https://discord.gg/gk8jAdXWmj)** - Ask in #bmad-method-help or #report-bugs-and-issues
+- **[GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)** - Report bugs or request features
+
+## Further Reading
+
+- **[What Are Agents](/docs/explanation/core-concepts/what-are-agents.md)** - Deep technical details on agent types
+- **[Agent Customization](/docs/how-to/customization/customize-agents.md)** - Modify agents without editing core files
+- **[Custom Content Installation](/docs/how-to/installation/install-custom-modules.md)** - Package and distribute your agents
+
+:::tip[Key Takeaways]
+- **Start small** - Your first agent should solve one problem well
+- **Persona matters** - Strong principles activate the agent's expertise
+- **Iterate often** - Test your agent and refine based on behavior
+- **Learn from examples** - Study reference agents before building your own
+:::

package/docs/tutorials/getting-started/getting-started-bmadv6.md

@@ -0,0 +1,246 @@
+---
+title: "Getting Started with the BMad Method"
+description: Install BMad and build your first project
+---
+
+**Upgrading from previous versions?** See the [Upgrade Guide](/docs/how-to/installation/upgrade-to-v6.md) instead.
+
+---
+
+Build software faster using AI-powered workflows with specialized agents that guide you through planning, architecture, and implementation.
+
+## What You'll Learn
+
+- Install and initialize BMad Method for a new project
+- Choose the right planning track for your project size
+- Progress through phases from requirements to working code
+- Use agents and workflows effectively
+
+:::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@alpha 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       | Brainstorming, research, product brief *(optional)* |
+| 2     | Planning       | Create requirements (PRD or tech-spec)              |
+| 3     | Solutioning    | Design architecture *(BMad Method/Enterprise only)* |
+| 4     | Implementation | Build epic by epic, story by story                  |
+
+![BMad Method Workflow - Standard Greenfield](./images/workflow-method-greenfield.svg)
+
+*Complete visual flowchart showing all phases, workflows, and agents for the standard greenfield track.*
+
+Based on your project's complexity, BMad offers three planning tracks:
+
+| Track           | Best For                                               | Documents Created                      |
+| --------------- | ------------------------------------------------------ | -------------------------------------- |
+| **Quick Flow**  | Bug fixes, simple features, clear scope (1-15 stories) | Tech-spec only                         |
+| **BMad Method** | Products, platforms, complex features (10-50+ stories) | PRD + Architecture + UX                |
+| **Enterprise**  | Compliance, multi-tenant systems (30+ stories)         | PRD + Architecture + Security + DevOps |
+
+:::note
+Story counts are guidance, not definitions. Choose your track based on planning needs, not story math.
+:::
+
+## Installation
+
+Open a terminal in your project directory and run:
+
+```bash
+npx bmad-method@alpha install
+```
+
+The interactive installer guides you through setup and creates a `_bmad/` folder with all agents and workflows.
+
+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](/docs/how-to/installation/install-bmad.md) for common solutions.
+:::
+
+## Step 1: Initialize Your Project
+
+Load the **Analyst agent** in your IDE, wait for the menu, then run `workflow-init`.
+
+:::note[How to Load Agents]
+Type `/<agent-name>` in your IDE and use autocomplete. Not sure what's available? Start with `/bmad` to see all agents and workflows.
+:::
+
+The workflow asks you to describe your project, whether it's new or existing, and the general complexity. Based on your description, it recommends a planning track.
+
+Once you confirm, the workflow creates `bmm-workflow-status.yaml` to track your progress through all phases.
+
+:::caution[Fresh Chats]
+Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
+:::
+
+## Step 2: Create Your Plan
+
+After initialization, work through phases 1-3. **Use fresh chats for each workflow.**
+
+:::tip[Check Your Status]
+Unsure what's next? Load any agent and ask for `workflow-status`. It tells you the next recommended or required workflow.
+:::
+
+### Phase 1: Analysis (Optional)
+
+All workflows in this phase are optional:
+- **brainstorm-project** — Guided ideation
+- **research** — Market and technical research
+- **product-brief** — Recommended foundation document
+
+### Phase 2: Planning (Required)
+
+**For BMad Method and Enterprise tracks:**
+1. Load the **PM agent** in a new chat
+2. Run the PRD workflow: `*prd`
+3. Output: `PRD.md`
+
+**For Quick Flow track:**
+- Use `tech-spec` instead of PRD, then skip to implementation
+
+:::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 (BMad Method/Enterprise)
+
+**Create Architecture**
+1. Load the **Architect agent** in a new chat
+2. Run `create-architecture`
+3. Output: Architecture document with technical decisions
+
+**Create Epics and Stories**
+
+:::tip[V6 Improvement]
+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. Load the **PM agent** in a new chat
+2. Run `create-epics-and-stories`
+3. The workflow uses both PRD and Architecture to create technically-informed stories
+
+**Implementation Readiness Check** *(Highly Recommended)*
+1. Load the **Architect agent** in a new chat
+2. Run `implementation-readiness`
+3. Validates cohesion across all planning documents
+
+## Step 3: Build Your Project
+
+Once planning is complete, move to implementation. **Each workflow should run in a fresh chat.**
+
+### 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    | TEA   | `automate`     | Generate guardrail tests *(optional)* |
+| 4    | 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, Epics & Stories)
+- 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
+│   ├── epics/                     # Epic and story files
+│   ├── bmm-workflow-status.yaml   # Phase progress tracking
+│   └── sprint-status.yaml         # Sprint 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         |
+| `*create-epics-and-stories` | PM        | Break down PRD into epics            |
+| `*implementation-readiness` | Architect | Validate planning cohesion           |
+| `*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 always need architecture?**
+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 `correct-course` workflow for handling scope changes.
+
+**What if I want to brainstorm first?**
+Load the Analyst agent and run `brainstorm-project` before `workflow-init`.
+
+**Can I skip workflow-init and workflow-status?**
+Yes, once you learn the flow. Use the Quick Reference to go directly to needed workflows.
+
+## Getting Help
+
+- **During workflows** — Agents guide you with questions and explanations
+- **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
+- **Documentation** — [BMM Workflow Reference](/docs/reference/workflows/index.md)
+- **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/docs/tutorials/getting-started/quick-start-bmgd.md

@@ -0,0 +1,260 @@
+---
+title: "Getting Started with BMad Game Development"
+description: Build games with BMad's Game Development Module
+---
+
+
+Build games faster using AI-powered workflows with specialized game development agents that guide you through preproduction, design, architecture, and implementation.
+
+:::note[Module Extension]
+BMGD (BMad Game Development) is a module that extends BMad Method. You'll need BMad installed first—see the [BMad v6 tutorial](/docs/tutorials/getting-started/getting-started-bmadv6.md) if you haven't installed it yet.
+:::
+
+## What You'll Learn
+
+- Install and configure the BMGD module
+- Understand game development phases and specialized agents
+- Create a Game Brief and Game Design Document (GDD)
+- Progress from concept to working game code
+
+:::note[Prerequisites]
+- **BMad Method installed** — Follow the main installation guide first
+- **A game idea** — Even a rough concept is enough to start
+- **AI-powered IDE** — Claude Code, Cursor, Windsurf, or similar
+:::
+
+:::tip[Quick Path]
+**Install** → `npx bmad-method install` (select BMGD module)
+**Preproduction** → Game Designer creates Game Brief
+**Design** → Game Designer creates GDD (and Narrative if story-driven)
+**Technical** → Game Architect creates Architecture
+**Production** → Game SM manages sprints, Game Dev implements
+**Always use fresh chats** for each workflow to avoid context issues.
+:::
+
+## Understanding BMGD
+
+BMGD follows four game development phases with specialized agents for each:
+
+| Phase | Name          | What Happens                                                      |
+| ----- | ------------- | ----------------------------------------------------------------- |
+| 1     | Preproduction | Capture game vision, create Game Brief *(optional brainstorming)* |
+| 2     | Design        | Detail mechanics, systems, narrative in GDD                       |
+| 3     | Technical     | Plan engine, architecture, technical decisions                    |
+| 4     | Production    | Build game in sprints, story by story                             |
+
+![BMGD Workflow Overview](./images/workflow-overview.jpg)
+
+*Complete visual flowchart showing all phases, workflows, and agents for game development.*
+
+### Game Development Agents
+
+| Agent                 | When to Use                               |
+| --------------------- | ----------------------------------------- |
+| **Game Designer**     | Brainstorming, Game Brief, GDD, Narrative |
+| **Game Architect**    | Architecture, technical decisions         |
+| **Game Developer**    | Implementation, code reviews              |
+| **Game Scrum Master** | Sprint planning, story management         |
+| **Game QA**           | Test framework, test design, automation   |
+| **Game Solo Dev**     | Quick prototyping, indie development      |
+
+## Installation
+
+If you haven't installed BMad yet:
+
+```bash
+npx bmad-method install
+```
+
+Or add BMGD to an existing installation:
+
+```bash
+npx bmad-method install --add-module bmgd
+```
+
+Verify your installation:
+
+```
+your-project/
+├── _bmad/
+│   ├── bmgd/           # Game development module
+│   │   ├── agents/     # Game-specific agents
+│   │   ├── workflows/  # Game-specific workflows
+│   │   └── config.yaml # Module config
+│   ├── bmm/            # Core method module
+│   └── core/           # Core utilities
+├── _bmad-output/       # Generated artifacts (created later)
+└── .claude/            # IDE configuration (if using Claude Code)
+```
+
+## Step 1: Create Your Game Brief (Preproduction)
+
+Load the **Game Designer** agent in your IDE, wait for the menu, then start with your game concept.
+
+### Optional: Brainstorm First
+
+If you have a vague idea and want help developing it:
+
+```
+Run brainstorm-game
+```
+
+The agent guides you through game-specific ideation techniques to refine your concept.
+
+### Create the Game Brief
+
+```
+Run create-game-brief
+```
+
+The Game Designer walks you through:
+- **Game concept** — Core idea and unique selling points
+- **Design pillars** — The 3-5 principles that guide all decisions
+- **Target market** — Who plays this game?
+- **Fundamentals** — Platform, genre, scope, team size
+
+When complete, you'll have `game-brief.md` in your `_bmad-output/` folder.
+
+:::caution[Fresh Chats]
+Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
+:::
+
+## Step 2: Design Your Game
+
+With your Game Brief complete, detail your game's design.
+
+### Create the GDD
+
+**Start a fresh chat** with the **Game Designer** agent.
+
+```
+Run create-gdd
+```
+
+The agent guides you through mechanics, systems, and game-type-specific sections. BMGD offers 24 game type templates that provide genre-specific structure.
+
+When complete, you'll have `gdd.md` (or sharded into `gdd/` for large documents).
+
+:::note[Narrative Design (Optional)]
+For story-driven games, start a fresh chat and run `narrative` to create a Narrative Design Document covering story, characters, world, and dialogue.
+:::
+
+:::tip[Check Your Status]
+Unsure what's next? Load any agent and run `workflow-status`. It tells you the next recommended workflow.
+:::
+
+## Step 3: Plan Your Architecture
+
+**Start a fresh chat** with the **Game Architect** agent.
+
+```
+Run create-architecture
+```
+
+The architect guides you through:
+- **Engine selection** — Unity, Unreal, Godot, custom, etc.
+- **System design** — Core game systems and how they interact
+- **Technical patterns** — Architecture patterns suited to your game
+- **Structure** — Project organization and conventions
+
+When complete, you'll have `game-architecture.md`.
+
+## Step 4: Build Your Game
+
+Once planning is complete, move to production. **Each workflow should run in a fresh chat.**
+
+### Initialize Sprint Planning
+
+Load the **Game Scrum Master** 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    | Game SM  | `create-story` | Create story file from epic        |
+| 2    | Game Dev | `dev-story`    | Implement the story                |
+| 3    | Game QA  | `automate`     | Generate tests *(optional)*        |
+| 4    | Game Dev | `code-review`  | Quality validation *(recommended)* |
+
+After completing all stories in an epic, load the **Game SM** and run `retrospective`.
+
+### Quick Prototyping Alternative
+
+For rapid iteration or indie development, load the **Game Solo Dev** agent:
+- `quick-prototype` — Rapid prototyping
+- `quick-dev` — Flexible development without full sprint structure
+
+## What You've Accomplished
+
+You've learned the foundation of building games with BMad:
+
+- Installed the BMGD module
+- Created a Game Brief capturing your vision
+- Detailed your design in a GDD
+- Planned your technical architecture
+- Understood the build cycle for implementation
+
+Your project now has:
+
+```
+your-project/
+├── _bmad/                         # BMad configuration
+├── _bmad-output/
+│   ├── game-brief.md              # Your game vision
+│   ├── gdd.md                     # Game Design Document
+│   ├── narrative-design.md        # Story design (if applicable)
+│   ├── game-architecture.md       # Technical decisions
+│   ├── epics/                     # Epic and story files
+│   └── sprint-status.yaml         # Sprint tracking
+└── ...
+```
+
+## Quick Reference
+
+| Command                | Agent          | Purpose                       |
+| ---------------------- | -------------- | ----------------------------- |
+| `*brainstorm-game`     | Game Designer  | Guided game ideation          |
+| `*create-game-brief`   | Game Designer  | Create Game Brief             |
+| `*create-gdd`          | Game Designer  | Create Game Design Document   |
+| `*narrative`           | Game Designer  | Create Narrative Design       |
+| `*create-architecture` | Game Architect | Create game architecture      |
+| `*sprint-planning`     | Game SM        | Initialize sprint tracking    |
+| `*create-story`        | Game SM        | Create a story file           |
+| `*dev-story`           | Game Dev       | Implement a story             |
+| `*code-review`         | Game Dev       | Review implemented code       |
+| `*workflow-status`     | Any            | Check progress and next steps |
+
+## Common Questions
+
+**Do I need to create all documents?**
+At minimum, create a Game Brief and GDD. Architecture is highly recommended. Narrative Design is only needed for story-driven games.
+
+**Can I use the Game Solo Dev for everything?**
+Yes, for smaller projects or rapid prototyping. For larger games, the specialized agents provide more thorough guidance.
+
+**What game types are supported?**
+BMGD includes 24 game type templates (RPG, platformer, puzzle, strategy, etc.) that provide genre-specific GDD sections.
+
+**Can I change my design later?**
+Yes. Documents are living artifacts—return to update them as your vision evolves. The SM agent has `correct-course` for scope changes.
+
+## Getting Help
+
+- **During workflows** — Agents guide you with questions and explanations
+- **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
+- **Documentation** — [BMGD Workflow Reference](/docs/reference/workflows/bmgd-workflows.md)
+- **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
+- **Game Brief first** — It informs everything that follows
+- **Use game type templates** — 24 templates provide genre-specific GDD structure
+- **Documents evolve** — Return to update them as your vision grows
+- **Solo Dev for speed** — Use Game Solo Dev for rapid prototyping
+:::
+
+Ready to start? Load the **Game Designer** agent and run `create-game-brief` to capture your game vision.

package/eslint.config.mjs

@@ -18,9 +18,9 @@ export default [
       'test/fixtures/**/*.yaml',
       '_bmad/**',
       '_bmad*/**',
-      // Docusaurus build artifacts
-      '.docusaurus/**',
+      // Build output
       'build/**',
+      // Website uses ESM/Astro - separate linting ecosystem
       'website/**',
       // Gitignored patterns
       'z*/**', // z-samples, z1, z2, etc.