bmad-method 6.0.5-next.8 → 6.1.0

package/docs/how-to/quick-fixes.md

@@ -1,123 +0,0 @@
----
-title: "Quick Fixes"
-description: How to make quick fixes and ad-hoc changes
-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.
-
-## When to Use This
-
-- Bug fixes with a clear, known cause
-- Small refactorings (rename, extract, restructure) contained within a few files
-- Minor feature tweaks or configuration changes
-- Exploratory work to understand an unfamiliar codebase
-
-:::note[Prerequisites]
-- BMad Method installed (`npx bmad-method install`)
-- An AI-powered IDE (Claude Code, Cursor, or similar)
-:::
-
-## Choose Your Approach
-
-| Situation | Agent | 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 |
-
-If you are unsure, start with the DEV agent. You can always escalate to Quick Flow if the change grows.
-
-## Steps
-
-### 1. Invoke the DEV Agent
-
-Start a **fresh chat** in your AI IDE and invoke the DEV agent skill:
-
-```text
-bmad-dev
-```
-
-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:
-
-```text
-bmad-quick-flow-solo-dev
-```
-
-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.
-
-:::tip[Fresh Chats]
-Always start a new chat session when loading an agent. Reusing a session from a previous workflow can cause context conflicts.
-:::
-
-### 2. Describe the Change
-
-Tell the agent what you need in plain language. Be specific about the problem and, if you know it, where the relevant code lives.
-
-:::note[Example Prompts]
-**Bug fix** -- "Fix the login validation bug that allows empty passwords. The validation logic is in `src/auth/validate.ts`."
-
-**Refactoring** -- "Refactor the UserService to use async/await instead of callbacks."
-
-**Configuration change** -- "Update the CI pipeline to cache node_modules between runs."
-
-**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.
-
-### 3. Let the Agent Work
-
-The agent 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).
-
-### 4. Review and Verify
-
-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
-
-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.
-:::
-
-## Learning Your Codebase
-
-The DEV agent is also useful for exploring unfamiliar code. Load it in a fresh chat and ask questions:
-
-:::note[Example Prompts]
-"Explain how the authentication system works in this codebase."
-
-"Show me where error handling happens in the API layer."
-
-"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.
-
-## What You Get
-
-- Modified source files with the fix or refactoring applied
-- Passing tests (if your project has a test suite)
-- A clean commit describing the change
-
-No planning artifacts are produced -- that's the point of this approach.
-
-## When to Upgrade to Formal Planning
-
-Consider using [Quick Flow](../explanation/quick-flow.md) or the full BMad Method when:
-
-- The change affects multiple systems or requires coordinated updates across many files
-- You are unsure about the scope and need a spec to think it through
-- The fix keeps growing in complexity as you work on it
-- You need documentation or architectural decisions recorded for the team

package/docs/how-to/shard-large-documents.md

@@ -1,78 +0,0 @@
----
-title: "Document Sharding Guide"
-description: Split large markdown files into smaller organized files for better context management
-sidebar:
-  order: 8
----
-
-Use the `bmad-shard-doc` tool if you need to split large markdown files into smaller, organized files for better context management.
-
-:::caution[Deprecated]
-This is no longer recommended, and soon with updated workflows and most major LLMs and tools supporting subprocesses this will be unnecessary.
-:::
-
-## When to Use This
-
-Only use this if you notice your chosen tool / model combination is failing to load and read all the documents as input when needed.
-
-## What is Document Sharding?
-
-Document sharding splits large markdown files into smaller, organized files based on level 2 headings (`## Heading`).
-
-### Architecture
-
-```text
-Before Sharding:
-_bmad-output/planning-artifacts/
-└── PRD.md (large 50k token file)
-
-After Sharding:
-_bmad-output/planning-artifacts/
-└── prd/
-    ├── index.md                    # Table of contents with descriptions
-    ├── overview.md                 # Section 1
-    ├── user-requirements.md        # Section 2
-    ├── technical-requirements.md   # Section 3
-    └── ...                         # Additional sections
-```
-
-## Steps
-
-### 1. Run the Shard-Doc Tool
-
-```bash
-/bmad-shard-doc
-```
-
-### 2. Follow the Interactive Process
-
-```text
-Agent: Which document would you like to shard?
-User: docs/PRD.md
-
-Agent: Default destination: docs/prd/
-       Accept default? [y/n]
-User: y
-
-Agent: Sharding PRD.md...
-       ✓ Created 12 section files
-       ✓ Generated index.md
-       ✓ Complete!
-```
-
-## How Workflow Discovery Works
-
-BMad workflows use a **dual discovery system**:
-
-1. **Try whole document first** - Look for `document-name.md`
-2. **Check for sharded version** - Look for `document-name/index.md`
-3. **Priority rule** - Whole document takes precedence if both exist - remove the whole document if you want the sharded to be used instead
-
-## Workflow Support
-
-All BMM workflows support both formats:
-
-- Whole documents
-- Sharded documents
-- Automatic detection
-- Transparent to user

package/docs/how-to/upgrade-to-v6.md

@@ -1,100 +0,0 @@
----
-title: "How to Upgrade to v6"
-description: Migrate from BMad v4 to v6
-sidebar:
-  order: 3
----
-
-Use the BMad installer to upgrade from v4 to v6, which includes automatic detection of legacy installations and migration assistance.
-
-## When to Use This
-
-- You have BMad v4 installed (`.bmad-method` folder)
-- You want to migrate to the new v6 architecture
-- You have existing planning artifacts to preserve
-
-:::note[Prerequisites]
-- Node.js 20+
-- Existing BMad v4 installation
-:::
-
-## Steps
-
-### 1. Run the Installer
-
-Follow the [Installer Instructions](./install-bmad.md).
-
-### 2. Handle Legacy Installation
-
-When v4 is detected, you can:
-
-- Allow the installer to back up and remove `.bmad-method`
-- Exit and handle cleanup manually
-
-If you named your bmad method folder something else - you will need to manually remove the folder yourself.
-
-### 3. Clean Up IDE Skills
-
-Manually remove legacy v4 IDE commands/skills - for example if you have Claude Code, look for any nested folders that start with bmad and remove them:
-
-- `.claude/commands/`
-
-The new v6 skills are installed to:
-
-- `.claude/skills/`
-
-### 4. Migrate Planning Artifacts
-
-**If you have planning documents (Brief/PRD/UX/Architecture):**
-
-Move them to `_bmad-output/planning-artifacts/` with descriptive names:
-
-- Include `PRD` in filename for PRD documents
-- Include `brief`, `architecture`, or `ux-design` accordingly
-- Sharded documents can be in named subfolders
-
-**If you're mid-planning:** Consider restarting with v6 workflows. Use your existing documents as inputs—the new progressive discovery workflows with web search and IDE plan mode produce better results.
-
-### 5. Migrate In-Progress Development
-
-If you have stories created or implemented:
-
-1. Complete the v6 installation
-2. Place `epics.md` or `epics/epic*.md` in `_bmad-output/planning-artifacts/`
-3. Run the Scrum Master's `bmad-sprint-planning` workflow
-4. Tell the SM which epics/stories are already complete
-
-## What You Get
-
-**v6 unified structure:**
-
-```text
-your-project/
-├── _bmad/               # Single installation folder
-│   ├── _config/         # Your customizations
-│   │   └── agents/      # Agent customization files
-│   ├── core/            # Universal core framework
-│   ├── bmm/             # BMad Method module
-│   ├── bmb/             # BMad Builder
-│   └── cis/             # Creative Intelligence Suite
-└── _bmad-output/        # Output folder (was doc folder in v4)
-```
-
-## Module Migration
-
-| v4 Module                     | v6 Status                                 |
-| ----------------------------- | ----------------------------------------- |
-| `.bmad-2d-phaser-game-dev`    | Integrated into BMGD Module               |
-| `.bmad-2d-unity-game-dev`     | Integrated into BMGD Module               |
-| `.bmad-godot-game-dev`        | Integrated into BMGD Module               |
-| `.bmad-infrastructure-devops` | Deprecated — new DevOps agent coming soon |
-| `.bmad-creative-writing`      | Not adapted — new v6 module coming soon   |
-
-## Key Changes
-
-| Concept       | v4                                    | v6                                   |
-| ------------- | ------------------------------------- | ------------------------------------ |
-| **Core**      | `_bmad-core` was actually BMad Method | `_bmad/core/` is universal framework |
-| **Method**    | `_bmad-method`                        | `_bmad/bmm/`                         |
-| **Config**    | Modified files directly               | `config.yaml` per module             |
-| **Documents** | Sharded or unsharded required setup   | Fully flexible, auto-scanned         |

package/docs/index.md

@@ -1,60 +0,0 @@
----
-title: Welcome to the BMad Method
-description: AI-driven development framework with specialized agents, guided workflows, and intelligent planning
----
-
-The BMad Method (**B**uild **M**ore **A**rchitect **D**reams) is an AI-driven development framework module within the BMad Method Ecosystem that helps you build software through the whole process from ideation and planning all the way through agentic implementation. It provides specialized AI agents, guided workflows, and intelligent planning that adapts to your project's complexity, whether you're fixing a bug or building an enterprise platform.
-
-If you're comfortable working with AI coding assistants like Claude, Cursor, or GitHub Copilot, you're ready to get started.
-
-:::note[🚀 V6 is Here and We're Just Getting Started!]
-Skills Architecture, BMad Builder v1, Dev Loop Automation, and so much more in the works. **[Check out the Roadmap →](/roadmap/)**
-:::
-
-## New Here? Start with a Tutorial
-
-The fastest way to understand BMad is to try it.
-
-- **[Get Started with BMad](./tutorials/getting-started.md)** — Install and understand how BMad works
-- **[Workflow Map](./reference/workflow-map.md)** — Visual overview of BMM phases, workflows, and context management
-
-:::tip[Just Want to Dive In?]
-Install BMad and use the `bmad-help` skill — it will guide you through everything based on your project and installed modules.
-:::
-
-## How to Use These Docs
-
-These docs are organized into four sections based on what you're trying to do:
-
-| Section           | Purpose                                                                                                    |
-| ----------------- | ---------------------------------------------------------------------------------------------------------- |
-| **Tutorials**     | Learning-oriented. Step-by-step guides that walk you through building something. Start here if you're new. |
-| **How-To Guides** | Task-oriented. Practical guides for solving specific problems. "How do I customize an agent?" lives here.  |
-| **Explanation**   | Understanding-oriented. Deep dives into concepts and architecture. Read when you want to know *why*.       |
-| **Reference**     | Information-oriented. Technical specifications for agents, workflows, and configuration.                   |
-
-## Extend and Customize
-
-Want to expand BMad with your own agents, workflows, or modules? The **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** provides the framework and tools for creating custom extensions, whether you're adding new capabilities to BMad or building entirely new modules from scratch.
-
-## What You'll Need
-
-BMad works with any AI coding assistant that supports custom system prompts or project context. Popular options include:
-
-- **[Claude Code](https://code.claude.com)** — Anthropic's CLI tool (recommended)
-- **[Cursor](https://cursor.sh)** — AI-first code editor
-- **[Codex CLI](https://github.com/openai/codex)** — OpenAI's terminal coding agent
-
-You should be comfortable with basic software development concepts like version control, project structure, and agile workflows. No prior experience with BMad-style agent systems is required—that's what these docs are for.
-
-## Join the Community
-
-Get help, share what you're building, or contribute to BMad:
-
-- **[Discord](https://discord.gg/gk8jAdXWmj)** — Chat with other BMad users, ask questions, share ideas
-- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Source code, issues, and contributions
-- **[YouTube](https://www.youtube.com/@BMadCode)** — Video tutorials and walkthroughs
-
-## Next Step
-
-Ready to dive in? **[Get Started with BMad](./tutorials/getting-started.md)** and build your first project.

package/docs/reference/agents.md

@@ -1,28 +0,0 @@
----
-title: Agents
-description: Default BMM agents with their skill IDs, menu triggers, and primary workflows
-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.
-
-## 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.
-- 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.
-
-| 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 |

package/docs/reference/commands.md

@@ -1,145 +0,0 @@
----
-title: Skills
-description: Reference for BMad skills — what they are, how they work, and where to find them.
-sidebar:
-  order: 3
----
-
-Skills are pre-built prompts that load agents, run workflows, or execute tasks inside your IDE. The BMad installer generates them from your installed modules at install time. If you later add, remove, or change modules, re-run the installer to keep skills in sync (see [Troubleshooting](#troubleshooting)).
-
-## Skills vs. Agent Menu Triggers
-
-BMad offers two ways to start work, and they serve different purposes.
-
-| Mechanism | How you invoke it | What happens |
-| --- | --- | --- |
-| **Skill** | Type the skill name (e.g. `bmad-help`) in your IDE | Directly loads an agent, runs a workflow, or executes a task |
-| **Agent menu trigger** | Load an agent first, then type a short code (e.g. `DS`) | The agent interprets the code and starts the matching workflow while staying in character |
-
-Agent menu triggers require an active agent session. Use skills when you know which workflow you want. Use triggers when you are already working with an agent and want to switch tasks without leaving the conversation.
-
-## How Skills Are Generated
-
-When you run `npx bmad-method install`, the installer reads the manifests for every selected module and writes one skill per agent, workflow, task, and tool. Each skill is a directory containing a `SKILL.md` file that instructs the AI to load the corresponding source file and follow its instructions.
-
-The installer uses templates for each skill type:
-
-| Skill type | What the generated file does |
-| --- | --- |
-| **Agent launcher** | Loads the agent persona file, activates its menu, and stays in character |
-| **Workflow skill** | Loads the workflow config and follows its steps |
-| **Task skill** | Loads a standalone task file and follows its instructions |
-| **Tool skill** | Loads a standalone tool file and follows its instructions |
-
-:::note[Re-running the installer]
-If you add or remove modules, run the installer again. It regenerates all skill files to match your current module selection.
-:::
-
-## Where Skill Files Live
-
-The installer writes skill files into an IDE-specific directory inside your project. The exact path depends on which IDE you selected during installation.
-
-| IDE / CLI | Skills directory |
-| --- | --- |
-| Claude Code | `.claude/skills/` |
-| Cursor | `.cursor/skills/` |
-| Windsurf | `.windsurf/skills/` |
-| Other IDEs | See the installer output for the target path |
-
-Each skill is a directory containing a `SKILL.md` file. For example, a Claude Code installation looks like:
-
-```text
-.claude/skills/
-├── bmad-help/
-│   └── SKILL.md
-├── bmad-create-prd/
-│   └── SKILL.md
-├── bmad-dev/
-│   └── SKILL.md
-└── ...
-```
-
-The directory name determines the skill name in your IDE. For example, the directory `bmad-dev/` registers the skill `bmad-dev`.
-
-## How to Discover Your Skills
-
-Type the skill name in your IDE to invoke it. Some platforms require you to enable skills in settings before they appear.
-
-Run `bmad-help` for context-aware guidance on your next step.
-
-:::tip[Quick discovery]
-The generated skill directories in your project are the canonical list. Open them in your file explorer to see every skill with its description.
-:::
-
-## Skill Categories
-
-### Agent Skills
-
-Agent skills load a specialized AI persona with a defined role, communication style, and menu of workflows. Once loaded, the agent stays in character and responds to menu triggers.
-
-| 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-architect` | Winston (Architect) | Designs system architecture |
-| `bmad-sm` | Bob (Scrum Master) | Manages sprints and stories |
-
-See [Agents](./agents.md) for the full list of default agents and their triggers.
-
-### Workflow Skills
-
-Workflow skills run a structured, multi-step process without loading an agent persona first. They load a workflow configuration and follow its steps.
-
-| Example skill | Purpose |
-| --- | --- |
-| `bmad-create-prd` | Create a Product Requirements Document |
-| `bmad-create-architecture` | Design system architecture |
-| `bmad-create-epics-and-stories` | Create epics and stories |
-| `bmad-dev-story` | Implement a story |
-| `bmad-code-review` | Run a code review |
-| `bmad-quick-spec` | Define an ad-hoc change (Quick Flow) |
-
-See [Workflow Map](./workflow-map.md) for the complete workflow reference organized by phase.
-
-### Task and Tool Skills
-
-Tasks and tools are standalone operations that do not require an agent or workflow context.
-
-#### BMad-Help: Your Intelligent Guide
-
-**`bmad-help`** is your primary interface for discovering what to do next. It's not just a lookup tool — it's an intelligent assistant that:
-
-- **Inspects your project** to see what's already been done
-- **Understands natural language queries** — ask questions in plain English
-- **Varies by installed modules** — shows options based on what you have
-- **Auto-invokes after workflows** — every workflow ends with clear next steps
-- **Recommends the first required task** — no guessing where to start
-
-**Examples:**
-
-```
-bmad-help
-bmad-help I have a SaaS idea and know all the features. Where do I start?
-bmad-help What are my options for UX design?
-bmad-help I'm stuck on the PRD workflow
-```
-
-#### Other Tasks and Tools
-
-| Example skill | Purpose |
-| --- | --- |
-| `bmad-shard-doc` | Split a large markdown file into smaller sections |
-| `bmad-index-docs` | Index project documentation |
-| `bmad-editorial-review-prose` | Review document prose quality |
-
-## 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.
-
-## Troubleshooting
-
-**Skills not appearing after install.** Some platforms require skills to be explicitly enabled in settings. Check your IDE's documentation or ask your AI assistant how to enable skills. You may also need to restart your IDE or reload the window.
-
-**Expected skills are missing.** The installer only generates skills for modules you selected. Run `npx bmad-method install` again and verify your module selection. Check that the skill files exist in the expected directory.
-
-**Skills from a removed module still appear.** The installer does not delete old skill files automatically. Remove the stale directories from your IDE's skills directory, or delete the entire skills directory and re-run the installer for a clean set.

package/docs/reference/modules.md

@@ -1,76 +0,0 @@
----
-title: Official Modules
-description: Add-on modules for building custom agents, creative intelligence, game development, and testing
-sidebar:
-  order: 4
----
-
-BMad extends through official modules that you select during installation. These add-on modules provide specialized agents, workflows, and tasks for specific domains beyond the built-in core and BMM (Agile suite).
-
-:::tip[Installing Modules]
-Run `npx bmad-method install` and select the modules you want. The installer handles downloading, configuration, and IDE integration automatically.
-:::
-
-## BMad Builder
-
-Create custom agents, workflows, and domain-specific modules with guided assistance. BMad Builder is the meta-module for extending the framework itself.
-
-- **Code:** `bmb`
-- **npm:** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
-- **GitHub:** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
-
-**Provides:**
-
-- Agent Builder -- create specialized AI agents with custom expertise and tool access
-- Workflow Builder -- design structured processes with steps and decision points
-- Module Builder -- package agents and workflows into shareable, publishable modules
-- Interactive setup with YAML configuration and npm publishing support
-
-## Creative Intelligence Suite
-
-AI-powered tools for structured creativity, ideation, and innovation during early-stage development. The suite provides multiple agents that facilitate brainstorming, design thinking, and problem-solving using proven frameworks.
-
-- **Code:** `cis`
-- **npm:** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
-- **GitHub:** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
-
-**Provides:**
-
-- Innovation Strategist, Design Thinking Coach, and Brainstorming Coach agents
-- Problem Solver and Creative Problem Solver for systematic and lateral thinking
-- Storyteller and Presentation Master for narratives and pitches
-- Ideation frameworks including SCAMPER, Reverse Brainstorming, and problem reframing
-
-## Game Dev Studio
-
-Structured game development workflows adapted for Unity, Unreal, Godot, and custom engines. Supports rapid prototyping through Quick Flow and full-scale production with epic-driven sprints.
-
-- **Code:** `gds`
-- **npm:** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
-- **GitHub:** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
-
-**Provides:**
-
-- Game Design Document (GDD) generation workflow
-- Quick Dev mode for rapid prototyping
-- Narrative design support for characters, dialogue, and world-building
-- Coverage for 21+ game types with engine-specific architecture guidance
-
-## 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.
-
-- **Code:** `tea`
-- **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
-- **GitHub:** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
-
-**Provides:**
-
-- Murat agent (Master Test Architect and Quality Advisor)
-- Workflows for test design, ATDD, automation, test review, and traceability
-- NFR assessment, CI setup, and framework scaffolding
-- P0-P3 prioritization with optional Playwright Utils and MCP integrations
-
-## Community Modules
-
-Community modules and a module marketplace are coming. Check the [BMad GitHub organization](https://github.com/bmad-code-org) for updates.