bmad-method 4.42.1 → 4.43.1

package/dist/teams/team-all.txt

@@ -1068,6 +1068,7 @@ npx bmad-method install
   - **Cline**: VS Code extension with AI features
   - **Roo Code**: Web-based IDE with agent support
   - **GitHub Copilot**: VS Code extension with AI peer programming assistant
+  - **Auggie CLI (Augment Code)**: AI-powered development environment
 
 **Note for VS Code Users**: BMAD-METHOD™ assumes when you mention "VS Code" that you're using it with an AI-powered extension like GitHub Copilot, Cline, or Roo. Standard VS Code without AI capabilities cannot run BMad agents. The installer includes built-in support for Cline and Roo.
 
@@ -4627,8 +4628,8 @@ sections:
           - **UI/UX Consistency:** {{ui_compatibility}}
           - **Performance Impact:** {{performance_constraints}}
 
-  - id: tech-stack-alignment
-    title: Tech Stack Alignment
+  - id: tech-stack
+    title: Tech Stack
     instruction: |
       Ensure new components align with existing technology choices:
 
@@ -4790,8 +4791,8 @@ sections:
 
           **Error Handling:** {{error_handling_strategy}}
 
-  - id: source-tree-integration
-    title: Source Tree Integration
+  - id: source-tree
+    title: Source Tree
     instruction: |
       Define how new code will integrate with existing project structure:
 
@@ -4860,7 +4861,7 @@ sections:
           **Monitoring:** {{monitoring_approach}}
 
   - id: coding-standards
-    title: Coding Standards and Conventions
+    title: Coding Standards
     instruction: |
       Ensure new code follows existing project conventions:
 
@@ -6672,7 +6673,7 @@ To comprehensively validate a story draft before implementation begins, ensuring
 
 ### 1. Template Completeness Validation
 
-- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- Load `.bmad-core/templates/story-tmpl.yaml` and extract all section headings from the template
 - **Missing sections check**: Compare story sections against template sections to verify all required sections are present
 - **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
 - **Agent section verification**: Confirm all sections from template exist for future agent use

package/dist/teams/team-fullstack.txt

@@ -902,6 +902,7 @@ npx bmad-method install
   - **Cline**: VS Code extension with AI features
   - **Roo Code**: Web-based IDE with agent support
   - **GitHub Copilot**: VS Code extension with AI peer programming assistant
+  - **Auggie CLI (Augment Code)**: AI-powered development environment
 
 **Note for VS Code Users**: BMAD-METHOD™ assumes when you mention "VS Code" that you're using it with an AI-powered extension like GitHub Copilot, Cline, or Roo. Standard VS Code without AI capabilities cannot run BMad agents. The installer includes built-in support for Cline and Roo.
 
@@ -6512,8 +6513,8 @@ sections:
           - **UI/UX Consistency:** {{ui_compatibility}}
           - **Performance Impact:** {{performance_constraints}}
 
-  - id: tech-stack-alignment
-    title: Tech Stack Alignment
+  - id: tech-stack
+    title: Tech Stack
     instruction: |
       Ensure new components align with existing technology choices:
 
@@ -6675,8 +6676,8 @@ sections:
 
           **Error Handling:** {{error_handling_strategy}}
 
-  - id: source-tree-integration
-    title: Source Tree Integration
+  - id: source-tree
+    title: Source Tree
     instruction: |
       Define how new code will integrate with existing project structure:
 
@@ -6745,7 +6746,7 @@ sections:
           **Monitoring:** {{monitoring_approach}}
 
   - id: coding-standards
-    title: Coding Standards and Conventions
+    title: Coding Standards
     instruction: |
       Ensure new code follows existing project conventions:
 
@@ -8396,7 +8397,7 @@ To comprehensively validate a story draft before implementation begins, ensuring
 
 ### 1. Template Completeness Validation
 
-- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- Load `.bmad-core/templates/story-tmpl.yaml` and extract all section headings from the template
 - **Missing sections check**: Compare story sections against template sections to verify all required sections are present
 - **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
 - **Agent section verification**: Confirm all sections from template exist for future agent use

package/dist/teams/team-ide-minimal.txt

@@ -822,6 +822,7 @@ npx bmad-method install
   - **Cline**: VS Code extension with AI features
   - **Roo Code**: Web-based IDE with agent support
   - **GitHub Copilot**: VS Code extension with AI peer programming assistant
+  - **Auggie CLI (Augment Code)**: AI-powered development environment
 
 **Note for VS Code Users**: BMAD-METHOD™ assumes when you mention "VS Code" that you're using it with an AI-powered extension like GitHub Copilot, Cline, or Roo. Standard VS Code without AI capabilities cannot run BMad agents. The installer includes built-in support for Cline and Roo.
 
@@ -2141,7 +2142,7 @@ To comprehensively validate a story draft before implementation begins, ensuring
 
 ### 1. Template Completeness Validation
 
-- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- Load `.bmad-core/templates/story-tmpl.yaml` and extract all section headings from the template
 - **Missing sections check**: Compare story sections against template sections to verify all required sections are present
 - **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
 - **Agent section verification**: Confirm all sections from template exist for future agent use

package/dist/teams/team-no-ui.txt

@@ -848,6 +848,7 @@ npx bmad-method install
   - **Cline**: VS Code extension with AI features
   - **Roo Code**: Web-based IDE with agent support
   - **GitHub Copilot**: VS Code extension with AI peer programming assistant
+  - **Auggie CLI (Augment Code)**: AI-powered development environment
 
 **Note for VS Code Users**: BMAD-METHOD™ assumes when you mention "VS Code" that you're using it with an AI-powered extension like GitHub Copilot, Cline, or Roo. Standard VS Code without AI capabilities cannot run BMad agents. The installer includes built-in support for Cline and Roo.
 
@@ -6049,8 +6050,8 @@ sections:
           - **UI/UX Consistency:** {{ui_compatibility}}
           - **Performance Impact:** {{performance_constraints}}
 
-  - id: tech-stack-alignment
-    title: Tech Stack Alignment
+  - id: tech-stack
+    title: Tech Stack
     instruction: |
       Ensure new components align with existing technology choices:
 
@@ -6212,8 +6213,8 @@ sections:
 
           **Error Handling:** {{error_handling_strategy}}
 
-  - id: source-tree-integration
-    title: Source Tree Integration
+  - id: source-tree
+    title: Source Tree
     instruction: |
       Define how new code will integrate with existing project structure:
 
@@ -6282,7 +6283,7 @@ sections:
           **Monitoring:** {{monitoring_approach}}
 
   - id: coding-standards
-    title: Coding Standards and Conventions
+    title: Coding Standards
     instruction: |
       Ensure new code follows existing project conventions:
 
@@ -7933,7 +7934,7 @@ To comprehensively validate a story draft before implementation begins, ensuring
 
 ### 1. Template Completeness Validation
 
-- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- Load `.bmad-core/templates/story-tmpl.yaml` and extract all section headings from the template
 - **Missing sections check**: Compare story sections against template sections to verify all required sections are present
 - **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
 - **Agent section verification**: Confirm all sections from template exist for future agent use

package/docs/GUIDING-PRINCIPLES.md

@@ -1,6 +1,6 @@
 # BMad Method Guiding Principles
 
-The BMad Method is a natural language framework for AI-assisted software development. These principles ensure contributions maintain the method's effectiveness.
+The BMad Core and Method is a natural language framework for AI-assisted workflow with human in the loop processing along with software development. These principles ensure contributions maintain the method's effectiveness.
 
 ## Core Principles
 
@@ -8,7 +8,7 @@ The BMad Method is a natural language framework for AI-assisted software develop
 
 - **Minimize dev agent dependencies**: Development agents that work in IDEs must have minimal context overhead
 - **Save context for code**: Every line counts - dev agents should focus on coding, not documentation
-- **Web agents can be larger**: Planning agents (PRD Writer, Architect) used in web UI can have more complex tasks and dependencies
+- **Planning agents can be larger**: Planning agents (PM, Architect) used in web UI can have more complex tasks and dependencies
 - **Small files, loaded on demand**: Multiple small, focused files are better than large files with many branches
 
 ### 2. Natural Language First
@@ -85,7 +85,7 @@ Templates follow the [BMad Document Template](../common/utils/bmad-doc-template.
 
 ## Remember
 
-- The power is in natural language orchestration, not code
+- The power is in natural language orchestration and human agent collaboration, not code
 - Dev agents code, planning agents plan
 - Keep dev agents lean for maximum coding efficiency
 - Expansion packs handle specialized domains

package/docs/expansion-packs.md

@@ -18,7 +18,7 @@ Each expansion pack provides deep, specialized knowledge without bloating the co
 
 Anyone can create and share expansion packs, fostering a ecosystem of AI-powered solutions across all industries and interests.
 
-## Technical Expansion Packs
+## Technical Expansion Packs (Examples of possible expansions to come)
 
 ### Game Development Pack
 
@@ -191,90 +191,10 @@ Research acceleration tools:
 
 ## Creating Your Own Expansion Pack
 
-### Step 1: Define Your Domain
-
-What expertise are you capturing? What problems will it solve?
-
-### Step 2: Design Your Agents
-
-Each agent should have:
-
-- Clear expertise area
-- Specific personality traits
-- Defined capabilities
-- Knowledge boundaries
-
-### Step 3: Create Tasks
-
-Tasks should be:
-
-- Step-by-step procedures
-- Reusable across scenarios
-- Clear and actionable
-- Domain-specific
-
-### Step 4: Build Templates
-
-Templates need:
-
-- Structured output format
-- Embedded LLM instructions
-- Placeholders for customization
-- Professional formatting
-
-### Step 5: Test & Iterate
-
-- Use with real scenarios
-- Gather user feedback
-- Refine agent responses
-- Improve task clarity
-
-### Step 6: Package & Share
-
-- Create clear documentation
-- Include usage examples
-- Add to expansion-packs directory
-- Share with community
-
-## The Future of Expansion Packs
-
-### Marketplace Potential
-
-Imagine a future where:
-
-- Professional expansion packs are sold
-- Certified packs for regulated industries
-- Community ratings and reviews
-- Automatic updates and improvements
-
-### AI Agent Ecosystems
-
-Expansion packs could enable:
-
-- Cross-pack agent collaboration
-- Industry-standard agent protocols
-- Interoperable AI workflows
-- Universal agent languages
-
-### Democratizing Expertise
-
-Every expansion pack:
-
-- Makes expert knowledge accessible
-- Reduces barriers to entry
-- Enables solo entrepreneurs
-- Empowers small teams
-
-## Getting Started
-
-1. **Browse existing packs**: Check `expansion-packs/` directory
-2. **Install what you need**: Use the installer's expansion pack option
-3. **Create your own**: Use the expansion-creator pack
-4. **Share with others**: Submit PRs with new packs
-5. **Build the future**: Help shape AI-assisted work
+The next major release will include a new agent and expansion pack builder and a new expansion format.
 
 ## Remember
 
-The BMad Method is more than a development framework - it's a platform for structuring human expertise into AI-accessible formats. Every expansion pack you create makes specialized knowledge more accessible to everyone.
+The BMad Method is more than a Software Development Agile Framework! Every expansion pack makes specialized knowledge and workflows more accessible to everyone.
 
 **What expertise will you share with the world?**

package/docs/flattener.md

@@ -0,0 +1,91 @@
+# Codebase Flattener Tool
+
+The BMAD-METHOD™ includes a powerful codebase flattener tool designed to prepare your project files for AI model consumption when uploading to web AI tools. This tool aggregates your entire codebase into a single XML file, making it easy to share your project context with AI assistants for analysis, debugging, or development assistance.
+
+## Features
+
+- **AI-Optimized Output**: Generates clean XML format specifically designed for AI model consumption
+- **Smart Filtering**: Automatically respects `.gitignore` patterns to exclude unnecessary files, plus optional project-level `.bmad-flattenignore` for additional exclusions if planning to flatten an existing repository for external update and analysis
+- **Binary File Detection**: Intelligently identifies and excludes binary files, focusing on source code
+- **Progress Tracking**: Real-time progress indicators and comprehensive completion statistics
+- **Flexible Output**: Customizable output file location and naming
+
+## Usage
+
+```bash
+# Basic usage - creates flattened-codebase.xml in current directory
+npx bmad-method flatten
+
+# Specify custom input directory
+npx bmad-method flatten --input /path/to/source/directory
+npx bmad-method flatten -i /path/to/source/directory
+
+# Specify custom output file
+npx bmad-method flatten --output my-project.xml
+npx bmad-method flatten -o /path/to/output/codebase.xml
+
+# Combine input and output options
+npx bmad-method flatten --input /path/to/source --output /path/to/output/codebase.xml
+```
+
+## Example Output
+
+The tool will display progress and provide a comprehensive summary:
+
+```text
+📊 Completion Summary:
+✅ Successfully processed 156 files into flattened-codebase.xml
+📁 Output file: /path/to/your/project/flattened-codebase.xml
+📏 Total source size: 2.3 MB
+📄 Generated XML size: 2.1 MB
+📝 Total lines of code: 15,847
+🔢 Estimated tokens: 542,891
+📊 File breakdown: 142 text, 14 binary, 0 errors
+```
+
+The generated XML file contains your project's text-based source files in a structured format that AI models can easily parse and understand, making it perfect for code reviews, architecture discussions, or getting AI assistance with your BMAD-METHOD™ projects.
+
+## Advanced Usage & Options
+
+- CLI options
+  - `-i, --input <path>`: Directory to flatten. Default: current working directory or auto-detected project root when run interactively.
+  - `-o, --output <path>`: Output file path. Default: `flattened-codebase.xml` in the chosen directory.
+- Interactive mode
+  - If you do not pass `--input` and `--output` and the terminal is interactive (TTY), the tool will attempt to detect your project root (by looking for markers like `.git`, `package.json`, etc.) and prompt you to confirm or override the paths.
+  - In non-interactive contexts (e.g., CI), it will prefer the detected root silently; otherwise it falls back to the current directory and default filename.
+- File discovery and ignoring
+  - Uses `git ls-files` when inside a git repository for speed and correctness; otherwise falls back to a glob-based scan.
+  - Applies your `.gitignore` plus a curated set of default ignore patterns (e.g., `node_modules`, build outputs, caches, logs, IDE folders, lockfiles, large media/binaries, `.env*`, and previously generated XML outputs).
+  - Supports an optional `.bmad-flattenignore` file at the project root for additional ignore patterns (gitignore-style). If present, its rules are applied after `.gitignore` and the defaults.
+
+## `.bmad-flattenignore` example
+
+Create a `.bmad-flattenignore` file in the root of your project to exclude files that must remain in git but should not be included in the flattened XML:
+
+```text
+seeds/**
+scripts/private/**
+**/*.snap
+```
+
+- Binary handling
+  - Binary files are detected and excluded from the XML content. They are counted in the final summary but not embedded in the output.
+- XML format and safety
+  - UTF-8 encoded file with root element `<files>`.
+  - Each text file is emitted as a `<file path="relative/path">` element whose content is wrapped in `<![CDATA[ ... ]]>`.
+  - The tool safely handles occurrences of `]]>` inside content by splitting the CDATA to preserve correctness.
+  - File contents are preserved as-is and indented for readability inside the XML.
+- Performance
+  - Concurrency is selected automatically based on your CPU and workload size. No configuration required.
+  - Running inside a git repo improves discovery performance.
+
+## Minimal XML example
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<files>
+  <file path="src/index.js"><![CDATA[
+    // your source content
+  ]]></file>
+</files>
+```

package/docs/versions.md

@@ -6,7 +6,7 @@
 - [Version 2](https://github.com/bmadcode/BMad-Method/tree/V2)
 - [Version 1](https://github.com/bmadcode/BMad-Method/tree/V1)
 
-## Current Version: V4 - Alpha
+## Current Version: V4
 
 Guiding Principles of V4:
 

package/docs/working-in-the-brownfield.md

@@ -1,11 +1,14 @@
 # Working in the Brownfield: A Complete Guide
 
-> **HIGHLY RECOMMENDED: Use Gemini Web or Gemini CLI for Brownfield Documentation Generation!**
->
-> Gemini Web's 1M+ token context window or Gemini CLI (when it's working) can analyze your ENTIRE codebase, or critical sections of it, all at once (obviously within reason):
->
-> - Upload via GitHub URL or use gemini cli in the project folder
-> - If working in the web: use `npx bmad-method flatten` to flatten your project into a single file, then upload that file to your web agent.
+## Critical Tip
+
+Regardless of what you plan for your existing project you want to start agentic coding with, producing contextual artifacts for agents is of the highest importance.
+
+If using Claude Code - it is recommended to use the document-project task with the architect to systematically produce important key artifacts for your codebase.
+
+Optionally you can product context information and understanding for your repo utilizing web agents like Gemini. If its already in github, you can provide the project URL in gemini and use the agents to help analyze or document the project with the team fullstack or the architect specific gem.
+
+If your project is too large, you can also flatten your codebase - which can make it easier to upload or use with some tools. You can read more about the optional tool in the [Flattener Guide](./flattener.md)
 
 ## What is Brownfield Development?
 
@@ -26,9 +29,15 @@ If you have just completed an MVP with BMad, and you want to continue with post-
 
 ## The Complete Brownfield Workflow
 
+Starting in the Web Option (potentially save some cost but a potentially more frustrating experience):
+
 1. **Follow the [<ins>User Guide - Installation</ins>](user-guide.md#installation) steps to setup your agent in the web.**
 2. **Generate a 'flattened' single file of your entire codebase** run: `npx bmad-method flatten`
 
+Starting in an IDE with large context and good models (Its important to use quality models for this process for the best results)
+
+1. In Claude Code or a similar IDE, select the architect agent and then use the \*document-project task. You will want to ensure you are validating and directing the agent to produce the best possible documents for LLMs to understand your code base, and not include any misleading or unnecessary info.
+
 ### Choose Your Approach
 
 #### Approach A: PRD-First (Recommended if adding very large and complex new features, single or multiple epics or massive changes)

package/expansion-packs/bmad-godot-game-dev/README.md

@@ -0,0 +1,244 @@
+# BMAD-Method BMAD Godot Expansion User Guide
+
+This guide will help you understand and effectively use the BMad Method Godot Expansion Pack for agile ai driven planning and development.
+
+## The BMad Plan and Execute Workflow
+
+**We will be following the user-guide in most cases, and modifications will be made for expansion pack specific usage**
+First, here is the full standard Greenfield Planning + Execution Workflow.
+
+### The Planning Workflow (Web UI or Powerful IDE Agents)
+
+Before development begins, BMad follows a structured planning workflow that's ideally done in web UI for cost efficiency:
+
+```mermaid
+graph TD
+    A["Start: Project Idea"] --> B{"Optional: Analyst Research"}
+    B -->|Yes| C["Analyst: Brainstorming (Optional)"]
+    B -->|No| G{"Project Brief Available?"}
+    C --> C2["Analyst: Market Research (Optional)"]
+    C2 --> C3["Analyst: Competitor Analysis (Optional)"]
+    C3 --> D["Game-Designer: Create Game Brief"]
+    D --> G
+    G -->|Yes| E["Game-Designer: Create GDD from Brief (Fast Track)"]
+    G -->|No| E2["Game-Designer: Interactive GDD Creation (More Questions)"]
+    E --> F["GDD Created with FRs, NFRs, Epics & Stories"]
+    E2 --> F
+    F --> F2["Game-PM: Create PRD from GDD"]
+    F2 --> F3["Game-Architect: Create Game Architecture from GDD and PRD"]
+    F3 --> I["PO: Run game-po-validation-checklist"]
+    I --> J{"Documents Aligned?"}
+    J -->|Yes| K["Planning Complete"]
+    J -->|No| L["Game-Designer: Update Epics & Stories"]
+    L --> M["Update GDD/Game Architecture as needed"]
+    M --> I
+    K --> N["📁 Switch to IDE (If in a Web Agent Platform)"]
+    N --> O["Game-PO: Shard Documents"]
+    O --> P["Ready for SM/Dev Cycle"]
+
+    style A fill:#f5f5f5,color:#000
+    style B fill:#e3f2fd,color:#000
+    style C fill:#e8f5e9,color:#000
+    style C2 fill:#e8f5e9,color:#000
+    style C3 fill:#e8f5e9,color:#000
+    style D fill:#e8f5e9,color:#000
+    style E fill:#fff3e0,color:#000
+    style E2 fill:#fff3e0,color:#000
+    style F fill:#fff3e0,color:#000
+    style F2 fill:#e3f2fd,color:#000
+    style F3 fill:#f3e5f5,color:#000
+    style G fill:#e3f2fd,color:#000
+    style H fill:#f3e5f5,color:#000
+    style H2 fill:#f3e5f5,color:#000
+    style I fill:#f9ab00,color:#fff
+    style J fill:#e3f2fd,color:#000
+    style K fill:#34a853,color:#fff
+    style L fill:#f9ab00,color:#fff
+    style M fill:#fff3e0,color:#000
+    style N fill:#1a73e8,color:#fff
+    style O fill:#f9ab00,color:#fff
+    style P fill:#34a853,color:#fff
+```
+
+#### Web UI to IDE Transition
+
+**Critical Transition Point**: Once the PO confirms document alignment, you must switch from web UI to IDE to begin the development workflow:
+
+1. **Copy Documents to Project**: Ensure `docs/gdd.md` and `docs/gamearchitecture.md` are in your project's docs folder (or a custom location you can specify during installation)
+2. **Switch to IDE**: Open your project in your preferred Agentic IDE
+3. **Document Sharding**: Use the Game-Designer to shard the GDD and then the game-architecht to shard the gamearchitecture
+4. **Begin Development**: Start the Core Development Cycle that follows
+
+### The Core Development Cycle (IDE)
+
+Once planning is complete and documents are sharded, BMad follows a structured development workflow:
+
+```mermaid
+graph TD
+    A["Development Phase Start"] --> B["Game-SM: Reviews Previous Story Dev/QA Notes"]
+    B --> B2["Game-SM: Drafts Next Story from Sharded Epic + Architecture"]
+    B2 --> B3{"Game-PO: Review Story Draft - Optional"}
+    B3 -->|Review Requested| B4["Game-QA: Review Story Against Artifacts"]
+    B3 -->|Skip Review| C{"User Approval"}
+    B4 --> C
+    C -->|Approved| D["Game-Dev: Sequential Task Execution"]
+    C -->|Needs Changes| B2
+    D --> E["Game-Dev: Implement Tasks + Tests"]
+    E --> F["Game-Dev: Run All Validations"]
+    F --> G["Game-Dev: Mark Ready for Review + Add Notes"]
+    G --> H{"User Verification"}
+    H -->|Request QA Review| I["Game-QA: Senior Dev Review + Active Refactoring"]
+    H -->|Approve Without QA| M["IMPORTANT: Verify All Regression Tests and Linting are Passing"]
+    I --> J["Game-QA: Review, Refactor Code, Add Tests, Document Notes"]
+    J --> L{"Game-QA Decision"}
+    L -->|Needs Dev Work| D
+    L -->|Approved| M
+    H -->|Needs Fixes| D
+    M --> N["IMPORTANT: COMMIT YOUR CHANGES BEFORE PROCEEDING!"]
+    N --> K["Mark Story as Done"]
+    K --> B
+
+    style A fill:#f5f5f5,color:#000
+    style B fill:#e8f5e9,color:#000
+    style B2 fill:#e8f5e9,color:#000
+    style B3 fill:#e3f2fd,color:#000
+    style B4 fill:#fce4ec,color:#000
+    style C fill:#e3f2fd,color:#000
+    style D fill:#e3f2fd,color:#000
+    style E fill:#e3f2fd,color:#000
+    style F fill:#e3f2fd,color:#000
+    style G fill:#e3f2fd,color:#000
+    style H fill:#e3f2fd,color:#000
+    style I fill:#f9ab00,color:#fff
+    style J fill:#ffd54f,color:#000
+    style K fill:#34a853,color:#fff
+    style L fill:#e3f2fd,color:#000
+    style M fill:#ff5722,color:#fff
+    style N fill:#d32f2f,color:#fff
+```
+
+## Installation
+
+### Optional
+
+If you want to do the planning in the Web with Claude (Sonnet 4 or Opus), Gemini Gem (2.5 Pro), or Custom GPT's:
+
+1. Navigate to `dist/expansion-packs/bmad-godot-game-dev/teams`
+2. Copy `godot-game-dev.txt` content
+3. Create new Gemini Gem or CustomGPT
+4. Upload file with instructions: "Your critical operating instructions are attached, do not break character as directed"
+5. Type `/help` to see available commands
+
+### IDE Project Setup
+
+```bash
+# Interactive installation (recommended)
+npx bmad-method install
+```
+
+## Special Agents
+
+There are two bmad agents - in the future they will be consolidated into the single bmad-master.
+
+### BMad-Master
+
+This agent can do any task or command that all other agents can do, aside from actual story implementation. Additionally, this agent can help explain the BMad Method when in the web by accessing the knowledge base and explaining anything to you about the process.
+
+If you dont want to bother switching between different agents aside from the dev, this is the agent for you.
+
+### BMad-Orchestrator
+
+This agent should NOT be used within the IDE, it is a heavy weight special purpose agent that utilizes a lot of context and can morph into any other agent. This exists solely to facilitate the team's within the web bundles. If you use a web bundle you will be greeted by the BMad Orchestrator.
+
+### How Agents Work
+
+#### Dependencies System
+
+Each agent has a YAML section that defines its dependencies:
+
+```yaml
+dependencies:
+  templates:
+    - prd-template.md
+    - user-story-template.md
+  tasks:
+    - create-doc.md
+    - shard-doc.md
+  data:
+    - bmad-kb.md
+```
+
+**Key Points:**
+
+- Agents only load resources they need (lean context)
+- Dependencies are automatically resolved during bundling
+- Resources are shared across agents to maintain consistency
+
+#### Agent Interaction
+
+**In IDE:**
+
+```bash
+# Some Ide's, like Cursor or Windsurf for example, utilize manual rules so interaction is done with the '@' symbol
+@game-designer Create a GDD for a task management app
+@game-architect Design the game architecture
+@game-developer Implement the user authentication
+
+# Some, like Claude Code use slash commands instead
+/game-sm Create user stories
+/game-developer Fix the login bug
+```
+
+#### Interactive Modes
+
+- **Incremental Mode**: Step-by-step with user input
+- **YOLO Mode**: Rapid generation with minimal interaction
+
+## IDE Integration
+
+### IDE Best Practices
+
+- **Context Management**: Keep relevant files only in context, keep files as lean and focused as necessary
+- **Agent Selection**: Use appropriate agent for task
+- **Iterative Development**: Work in small, focused tasks
+- **File Organization**: Maintain clean project structure
+
+## Technical Preferences System
+
+BMad includes a personalization system through the `technical-preferences.md` file located in `.bmad-godot-game-dev/data/` - this can help bias the PM and Architect to recommend your preferences for design patterns, technology selection, or anything else you would like to put in here.
+
+### Using with Web Bundles
+
+When creating custom web bundles or uploading to AI platforms, include your `technical-preferences.md` content to ensure agents have your preferences from the start of any conversation.
+
+## Core Configuration
+
+The `.bmad-core/core-config.yaml` and for this expansion-pack the `.bmad-godot-game-dev/config.yaml` files are a critical config that enables BMad to work seamlessly with differing project structures, more options will be made available in the future. Currently the most important is the devLoadAlwaysFiles list section in the yaml.
+
+For the expansion pack ensure you either copy the core-config.yaml.example from the expansion pack directory to replace your .bmad-core/core-config.yaml and copy it to the .bmad-unit-game-dev/ expansion pack as core-config.yaml and at the very least update the gameDimension variable to the dimension your game will be in.
+
+### Developer Context Files
+
+Define which files the dev agent should always load:
+
+```yaml
+devLoadAlwaysFiles:
+  - docs/architecture/##-coding-standards.md
+  - docs/architecture/##-tech-stack.md
+  - docs/architecture/##-godot-project-structure.md
+```
+
+You will want to verify from sharding your architecture that these documents exist (replace ## with the prefix generated in sharding), that they are as lean as possible, and contain exactly the information you want your dev agent to ALWAYS load into it's context. These are the rules the agent will follow.
+
+As your project grows and the code starts to build consistent patterns, coding standards should be reduced to just the items that the agent makes mistakes at still - must with the better models, they will look at surrounding code in files and not need a rule from that file to guide them.
+
+## Getting Help
+
+- **Discord Community**: [Join Discord](https://discord.gg/gk8jAdXWmj)
+- **GitHub Issues**: [Report bugs](https://github.com/bmadcode/bmad-method/issues)
+- **Documentation**: [Browse docs](https://github.com/bmadcode/bmad-method/docs)
+- **YouTube**: [BMadCode Channel](https://www.youtube.com/@BMadCode)
+
+## Conclusion
+
+Remember: BMad is designed to enhance your development process, not replace your expertise. Use it as a powerful tool to accelerate your projects while maintaining control over design decisions and implementation details.