# BMad Game Dev Studio Documentation (Full)
> Complete documentation for AI consumption
> Generated: 2026-02-08
> Repository: https://github.com/bmad-code-org/bmad-module-game-dev-studio
# BMad Game Dev Studio
BMGD brings BMad's structured development to game development. Create working prototypes quickly in Unity, Unreal, Godot—or any engine you choose.
---
## Supported Engines
BMGD has first-class support for:
- **[Unity](https://unity.com)** — C# scripting, industry-standard for many game types
- **[Unreal Engine](https://www.unrealengine.com/)** — Blueprint and C++, AAA powerhouse
- **[Godot](https://godotengine.org/)** — Open-source, GDScript, rapidly growing
But you're not limited to these—BMGD works with any platform.
---
## What BMGD Does
- **Product Research** — Market analysis, competitor research, positioning
- **Game Design Document** — Comprehensive GDD with mechanics, progression, and balance
- **Narrative Design** — Story structure, characters, dialogue, world-building
- **Technical Architecture** — Engine patterns, performance considerations
- **Production Planning** — Epic-driven sprints, story tracking, retrospectives
- **Quick Prototyping** — Skip the planning, jump straight into building
---
## Quick Start
| Workflow | Purpose |
|----------|---------|
| [Your first game project](tutorials/first-game-project.md) | Create your first prototype in 15-30 minutes |
| [Quick Flow vs Full Production](explanation/quick-flow-vs-full.md) | Choose your development approach |
| [Set up Unity](how-to/setup-unity.md) | Configure Unity for BMGD |
| [Set up Unreal](how-to/setup-unreal.md) | Configure Unreal for BMGD |
| [Set up Godot](how-to/setup-godot.md) | Configure Godot for BMGD |
---
## Quick Links
| Section | Purpose |
| ------- | ------- |
| **[Tutorials](tutorials/)** | Get started with BMGD |
| **[How-To Guides](how-to/)** | Practical guides for engines and workflows |
| **[Explanation](explanation/)** | Learn how BMGD works |
| **[Reference](reference/)** | Agents, workflows, and commands |
---
## Community
- **[Discord](https://discord.gg/gk8jAdXWmj)** — Get help from other game devs
- **[GitHub](https://github.com/bmad-code-org/bmad-module-game-dev-studio)** — Source code and issues
- **[BMad Method Docs](https://docs.bmad-method.org)** — Core framework documentation
# Your first game project with BMGD
Welcome to BMad Game Dev Studio (BMGD)! This tutorial will guide you through creating your first playable game prototype using BMGD's Quick Flow workflow.
## What you'll learn
- How BMGD's Quick Flow works for rapid prototyping
- Using Indie (Game Solo Dev) to accelerate development
- Creating your first playable game prototype from concept to test
## Prerequisites
Before starting, make sure you have:
- **BMad Method installed** with the BMGD module enabled
- **Basic familiarity** with game development concepts
- **A game engine installed** (Unity, Unreal, or Godot) — or you can follow along conceptually
---
## Step 1: Start your prototype
Begin by invoking the Quick Flow workflow. In your BMad-enabled environment, run:
```
/bmgd-quick-prototype
```
This summons **Indie** (the Game Solo Dev agent), who specializes in rapid prototyping and fast iteration.
Indie will ask you about your game concept. Don't worry if you only have a rough idea — that's perfect for Quick Flow.
---
## Step 2: Choose your game type
BMGD supports **24 game types**, each with specialized templates. Indie will help you select the one that fits your concept.
Common game types include:
| Game Type | Description | Examples |
|-----------|-------------|----------|
| Action Platformer | Jump, run, and overcome obstacles | Mario, Celeste |
| Puzzle | Solve challenges using logic | Tetris, Portal |
| RPG | Character progression and narrative | Final Fantasy, Undertale |
| Shooter | Combat through projectiles | Doom, Halo |
| Survival | Manage resources and stay alive | Minecraft, Don't Starve |
If you're unsure, describe your idea and Indie will recommend the best fit.
---
## Step 3: Define your core mechanic
Every great game centers on a **core mechanic** — the primary action players repeat throughout the game.
Indie will guide you to define:
- **The action:** What does the player do? (jump, shoot, match, build...)
- **The goal:** What is the player trying to achieve?
- **The challenge:** What makes it difficult or interesting?
**Example:** For a platformer, your core mechanic might be "jumping between platforms while avoiding enemies to reach the goal."
Keep it simple. Quick Flow is about testing ideas fast, not building everything at once.
---
## Step 4: Generate the prototype
Once you've defined your core mechanic, Indie generates your initial prototype structure:
- **Prototype specification** — What you're building and how it works
- **Basic game loop** — The core repeatable experience
- **Asset placeholders** — What art and audio you'll need
- **Next steps** — How to iterate and improve
This is your starting point. It's not a complete game — it's a **playable foundation** you can build on.
---
## Step 5: Review and iterate
Now the fun part: **playtest your prototype.**
Ask yourself:
- Is the core mechanic fun?
- Does the game loop feel satisfying?
- What's missing or confusing?
Quick Flow is designed for iteration. Make changes, test again, and refine. Indie can help you adjust and improve.
**Remember:** A playable prototype beats a perfect design document. Test early, test often.
---
## Congratulations!
You've created your first BMGD project! You now have:
- A game concept with a defined core mechanic
- A prototype specification ready for implementation
- Experience using BMGD's Quick Flow workflow
---
## Next steps
Your journey with BMGD is just beginning. Here's where to go from here:
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Understand when to use each approach
- **[Set up Unity with BMGD](../how-to/setup-unity.md)** — Engine-specific setup for Unity
- **[Set up Unreal with BMGD](../how-to/setup-unreal.md)** — Engine-specific setup for Unreal
- **[Set up Godot with BMGD](../how-to/setup-godot.md)** — Engine-specific setup for Godot
---
**Does it feel good? Ship it.** — Indie, Game Solo Dev
For more on BMGD's agents and workflows, see the [Agents Reference](../reference/agents.md).
# Tutorials
Complete guides for learning BMad Game Dev Studio (BMGD).
---
## Getting Started
**New to BMGD?** Start here:
- **[Your first game project with BMGD](./first-game-project.md)** — Create your first playable prototype in 15-30 minutes
---
## Game Development Phases
BMGD follows four phases aligned with game development:
### Phase 1: Preproduction
- Brainstorm Game — Ideation with game-specific techniques
- Game Brief — Capture vision, market, and fundamentals
### Phase 2: Design
- GDD (Game Design Document) — Comprehensive game design
- Narrative Design — Story, characters, world (for story-driven games)
### Phase 3: Technical
- Game Architecture — Engine, systems, patterns, structure
### Phase 4: Production
- Sprint Planning — Epic and story management
- Story Development — Implementation workflow
- Code Review — Quality assurance
- Testing — Automated tests, playtesting, performance
- Retrospective — Continuous improvement
---
## Choose Your Path
**Quick prototype**
- Use [Quick Flow](../how-to/quick-prototype.md) for rapid iteration
- Perfect for testing ideas and game jams
**Full production**
- Follow the phases above for structured development
- Use [engine setup guides](../how-to/) for Unity/Unreal/Godot
---
## Further Reading
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Choose your development approach
- **[Game Types](../explanation/game-types.md)** — Selecting game type templates
- **[BMGD vs BMM](../explanation/bmgd-vs-bmm.md)** — Understanding the differences
- **[Agents](../reference/agents.md)** — BMGD's specialized game development agents
# How-To Guides
Step-by-step guides for completing specific game development tasks with BMGD.
---
## Engine Setup Guides
Get started with your preferred game engine:
- **[Set up a Unity project with BMGD](./setup-unity.md)** — Configure Unity for full production development
- **[Set up an Unreal project with BMGD](./setup-unreal.md)** — Configure Unreal for full production development
- **[Set up a Godot project with BMGD](./setup-godot.md)** — Configure Godot for full production development
---
## Quick Flow Guides
Rapid prototyping and fast iteration:
- **[Quick Flow: Rapid prototyping](./quick-prototype.md)** — Create a playable prototype in hours (coming soon)
---
## Production Workflows
Plan, track, and implement your game:
- **[Run sprint planning](./sprint-planning.md)** — Plan and track development sprints
- **[Conduct code reviews](./code-review.md)** — Review code quality (coming soon)
- **[Course correction](./correct-course.md)** — Get back on track when implementation diverges (coming soon)
---
## Testing Guides
Set up and run testing for your game:
- **[Set up automated testing](./testing-setup.md)** — Initialize test frameworks (coming soon)
- **[Design game tests](./test-design.md)** — Create comprehensive test scenarios (coming soon)
- **[Plan playtesting sessions](./playtesting.md)** — Structure your playtesting (coming soon)
- **[Performance testing](./performance-testing.md)** — Design performance testing strategy (coming soon)
---
## Reference
For complete workflow and agent reference, see:
- **[Workflows Reference](../reference/workflows.md)** — All BMGD workflows
- **[Agents Reference](../reference/agents.md)** — All 6 BMGD agents
- **[Game Types Reference](../reference/game-types.md)** — All 24 game type templates
# Set up a Godot project with BMGD
Configure a new Godot project with BMGD workflows for full production game development.
---
## When to Use This Guide
- You're starting a new Godot game project
- You want to use BMGD's Full Production workflow
- You need formal documentation (GDD, architecture, sprint tracking)
---
## When to Skip This
- You just want to prototype quickly — use [Quick Flow](../tutorials/first-game-project.md) instead
- You're using Unity or Unreal — see the setup guides for those engines
- You're prototyping or doing a game jam — Quick Flow is faster
---
## Prerequisites
> **Before starting:**
> - BMad Method installed with BMGD module enabled
> - Godot 4.2+ (recommended) or Godot 3.x installed
> - Basic familiarity with Godot and GDScript
> - A game concept or idea you want to develop
---
## Steps
### Step 1: Create your Godot project
1. Open **Godot Project Manager**
2. Click **New Project**
3. Browse to your desired folder location
4. Choose a renderer:
- **Forward+** — Modern PBR, best for 3D games
- **Mobile** — Optimized for mobile platforms
- **Compatibility** — GLES2, for older hardware
5. Name your project folder
6. Click **Create & Edit**
### Step 2: Generate your project context
BMGD uses a `project-context.md` file to maintain consistency across all workflows.
In your BMad-enabled environment at the project root:
```
/bmgd-generate-project-context
```
This invokes the **Game Architect (Cloud Dragonborn)** to create a `project-context.md` file that includes:
- Project name and description
- Target platforms (PC, mobile, web)
- Engine version and renderer choice
- Performance budgets
- Critical technical decisions
### Step 3: Run the brainstorming workflow
Define your game concept with the Game Designer agent.
```
/bmgd-brainstorm-game
```
The **Game Designer (Samus Shepard)** will guide you through:
- Selecting and combining brainstorming techniques
- Generating and refining game ideas
- Choosing a concept to develop
### Step 4: Create your Game Brief
Capture your vision and positioning.
```
/bmgd-game-brief
```
The Game Designer creates `game-brief.md` with:
- Game vision and elevator pitch
- Target audience and market positioning
- Platform and genre decisions
- Competitive analysis
- Art and audio direction
### Step 5: Design your game (GDD)
Create a comprehensive Game Design Document.
```
/bmgd-create-gdd
```
The Game Designer helps you:
- Select your game type from 24 available templates
- Define core gameplay mechanics
- Design progression systems
- Plan levels and content
- Specify art and audio requirements
Output: `gdd.md`
### Step 6: Create your technical architecture
Plan your Godot project structure and systems.
```
/bmgd-create-architecture
```
The **Game Architect (Cloud Dragonborn)** creates `architecture.md` with:
- Project structure (scenes, scripts, resources)
- System architecture (game loop, nodes, signals, autoloads)
- Godot-specific patterns (tree organization, resource management)
- Performance budgets and optimization strategy
- Export configurations and platform settings
### Step 7: Plan your first sprint
Ready to start building? Use the Game Scrum Master to plan your work.
```
/bmgd-sprint-planning
```
The **Game Scrum Master (Max)** creates:
- `sprint-status.yaml` — Your sprint tracking file
- Stories from your GDD and Architecture
- Sprint goals and definition of done
### Step 8: Start implementing
Build features with the Game Developer agent.
```
/bmgd-dev-story [story-name]
```
The **Game Developer (Link Freeman)** helps you:
- Implement story tasks with GDScript
- Follow Godot best practices
- Write tests for your features
- Review code before marking complete
---
## What You Get
After completing this setup, you'll have:
| File/Folder | Purpose |
|------------|---------|
| `project-context.md` | AI context for consistency across all BMGD workflows |
| `game-brief.md` | Your game's vision and positioning |
| `gdd.md` | Complete game design document |
| `architecture.md` | Technical architecture and Godot-specific patterns |
| `sprint-status.yaml` | Sprint tracking with stories and progress |
| `stories/` | Folder containing individual story files |
---
## Godot-Specific Considerations
### Project Structure
BMGD recommends this Godot project structure:
```
res://
├── scenes/
│ ├── levels/
│ ├── characters/
│ ├── ui/
│ └── components/
├── scripts/
│ ├── autoload/
│ └── utils/
├── assets/
│ ├── art/
│ ├── audio/
│ └── data/
└── project.godot
```
### Scene Organization
Godot uses a tree of nodes. Your architecture should define:
- **Autoload Singletons** — Global managers (game state, audio, saves)
- **Scene Composition** — Reusable scenes (player, enemies, pickups)
- **Signal Patterns** — Decoupled communication between nodes
The Game Architect will specify these patterns in your `architecture.md`.
### Performance Budgets
Godot projects typically target:
- **60 FPS** for most games
- **30 FPS** for mobile with heavy computation
- **144+ FPS** for competitive games
Your `architecture.md` will specify frame time budgets.
### Testing Setup
For Godot automated testing, the Game QA agent (GLaDOS) can help:
```
/bmgd-test-framework
```
This sets up GUT (Godot Unit Test) with:
- Unit tests (script logic without scenes)
- Integration tests (scene interactions)
- Test fixtures and test doubles
---
## Tips
> **Best Practice:** Always run `bmgd-generate-project-context` after creating a new Godot project. The `project-context.md` file is the "single source of truth" that all BMGD agents reference.
> **Avoid:** Don't create deeply nested scene trees. Godot's scene system encourages composition — prefer many small scenes over one large scene.
> **Remember:** Godot uses GDScript (Python-like) by default. Your architecture should specify if you're using C# or GDScript — both are supported but have different workflows.
---
## Common Mistakes
| Mistake | Solution |
|---------|----------|
| Skipping project-context generation | Always generate `project-context.md` first — it guides all other workflows |
Creating monolithic scenes | Break your game into reusable scene components — the Game Architect can help design this |
Not using autoloads properly | Keep autoloads minimal — only use for true singletons (game state, save system) |
Mixing GDScript and C# arbitrarily | Choose one primary language and stick with it — mixing adds complexity without benefit |
---
## Next Steps
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Understand both development approaches
- **[Set up Unity with BMGD](./setup-unity.md)** — If you're considering Unity instead
- **[Run sprint planning](./sprint-planning.md)** — When you're ready to start building
- **[Agents Reference](../reference/agents.md)** — Learn about all 6 BMGD agents
# Set up a Unity project with BMGD
Configure a new Unity project with BMGD workflows for full production game development.
---
## When to Use This Guide
- You're starting a new Unity game project
- You want to use BMGD's Full Production workflow
- You need formal documentation (GDD, architecture, sprint tracking)
---
## When to Skip This
- You just want to prototype quickly — use [Quick Flow](../tutorials/first-game-project.md) instead
- You're using Unreal or Godot — see the setup guides for those engines
- You're prototyping or doing a game jam — Quick Flow is faster
---
## Prerequisites
> **Before starting:**
> - BMad Method installed with BMGD module enabled
> - Unity Hub and Unity 2022 LTS (or later) installed
> - Basic familiarity with Unity and C#
> - A game concept or idea you want to develop
---
## Steps
### Step 1: Create your Unity project
1. Open Unity Hub
2. Click **New Project**
3. Select the appropriate template for your game type:
- **2D** → Core 2D
- **3D** → 3D Core
- **URP** → Universal Render Pipeline (recommended for most games)
- **HDRP** → High Definition Render Pipeline (high-end visuals)
4. Name your project and choose a location
5. Click **Create Project**
### Step 2: Generate your project context
BMGD uses a `project-context.md` file to maintain consistency across all workflows.
In your BMad-enabled environment at the project root:
```
/bmgd-generate-project-context
```
This invokes the **Game Architect (Cloud Dragonborn)** to create a `project-context.md` file that includes:
- Project name and description
- Target platforms
- Engine and framework choices
- Performance budgets
- Critical technical decisions
### Step 3: Run the brainstorming workflow
Define your game concept with the Game Designer agent.
```
/bmgd-brainstorm-game
```
The **Game Designer (Samus Shepard)** will guide you through:
- Selecting and combining brainstorming techniques
- Generating and refining game ideas
- Choosing a concept to develop
### Step 4: Create your Game Brief
Capture your vision and positioning.
```
/bmgd-game-brief
```
The Game Designer creates `game-brief.md` with:
- Game vision and elevator pitch
- Target audience and market positioning
- Platform and genre decisions
- Competitive analysis
- Art and audio direction
### Step 5: Design your game (GDD)
Create a comprehensive Game Design Document.
```
/bmgd-create-gdd
```
The Game Designer helps you:
- Select your game type from 24 available templates
- Define core gameplay mechanics
- Design progression systems
- Plan levels and content
- Specify art and audio requirements
Output: `gdd.md`
### Step 6: Create your technical architecture
Plan your Unity project structure and systems.
```
/bmgd-create-architecture
```
The **Game Architect (Cloud Dragonborn)** creates `architecture.md` with:
- Project structure (folders, naming conventions)
- System architecture (game loop, input, physics, networking)
- Unity-specific patterns (ScriptableObjects, events, object pooling)
- Performance budgets and optimization strategy
- Asset pipeline and build configuration
### Step 7: Plan your first sprint
Ready to start building? Use the Game Scrum Master to plan your work.
```
/bmgd-sprint-planning
```
The **Game Scrum Master (Max)** creates:
- `sprint-status.yaml` — Your sprint tracking file
- Stories from your GDD and Architecture
- Sprint goals and definition of done
### Step 8: Start implementing
Build features with the Game Developer agent.
```
/bmgd-dev-story [story-name]
```
The **Game Developer (Link Freeman)** helps you:
- Implement story tasks with C# scripts
- Follow Unity best practices
- Write tests for your features
- Review code before marking complete
---
## What You Get
After completing this setup, you'll have:
| File/Folder | Purpose |
|------------|---------|
| `project-context.md` | AI context for consistency across all BMGD workflows |
| `game-brief.md` | Your game's vision and positioning |
| `gdd.md` | Complete game design document |
| `architecture.md` | Technical architecture and Unity-specific patterns |
| `sprint-status.yaml` | Sprint tracking with stories and progress |
| `stories/` | Folder containing individual story files |
---
## Unity-Specific Considerations
### Project Structure
BMGD recommends this Unity project structure:
```
Assets/
├── _Project/
│ ├── Scripts/
│ ├── Art/
│ ├── Audio/
│ └── Data/
├── Packages/
└── ProjectSettings/
```
### ScriptableObjects
Use ScriptableObjects for game data — the Game Architect will include this in your architecture:
- Game configuration
- Character stats
- Item definitions
- Level data
### Performance Budgets
Unity projects typically target:
- **60 FPS** for most platforms
- **30 FPS** for mobile (if targeting battery life)
- **120+ FPS** for VR/high-refresh gaming
Your `architecture.md` will specify your targets.
### Testing Setup
For Unity automated testing, the Game QA agent (GLaDOS) can help:
```
/bmgd-test-framework
```
This sets up Unity Test Framework with:
- Edit Mode tests (logic without running the game)
- Play Mode tests (gameplay systems)
- Test assembly structure
---
## Tips
> **Best Practice:** Always run `bmgd-generate-project-context` after creating a new Unity project. The `project-context.md` file is the "single source of truth" that all BMGD agents reference.
> **Avoid:** Don't manually organize your Assets folder before running `bmgd-create-architecture`. Let the Game Architect define the structure first, then follow it consistently.
> **Remember:** Unity projects can get large quickly. Use the architecture document to keep your project organized as it grows.
---
## Common Mistakes
| Mistake | Solution |
|---------|----------|
| Skipping project-context generation | Always generate `project-context.md` first — it guides all other workflows |
Choosing the wrong Unity template | Consult the Game Architect if unsure — your engine choice affects architecture |
Starting implementation before GDD | Complete the Design phase first — changes are cheaper before code is written |
Ignoring sprint planning | Even solo projects benefit from story tracking — it keeps you focused on ship |
---
## Next Steps
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Understand both development approaches
- **[Set up Unreal with BMGD](./setup-unreal.md)** — If you're considering Unreal instead
- **[Run sprint planning](./sprint-planning.md)** — When you're ready to start building
- **[Agents Reference](../reference/agents.md)** — Learn about all 6 BMGD agents
# Set up an Unreal project with BMGD
Configure a new Unreal project with BMGD workflows for full production game development.
---
## When to Use This Guide
- You're starting a new Unreal game project
- You want to use BMGD's Full Production workflow
- You need formal documentation (GDD, architecture, sprint tracking)
---
## When to Skip This
- You just want to prototype quickly — use [Quick Flow](../tutorials/first-game-project.md) instead
- You're using Unity or Godot — see the setup guides for those engines
- You're prototyping or doing a game jam — Quick Flow is faster
---
## Prerequisites
> **Before starting:**
> - BMad Method installed with BMGD module enabled
> - Unreal Engine 5.x installed
> - Basic familiarity with Unreal (Blueprints or C++)
> - A game concept or idea you want to develop
---
## Steps
### Step 1: Create your Unreal project
1. Open the **Epic Games Launcher**
2. Go to **Unreal Engine** tab
3. Click **Launch** to open Unreal Editor
4. In the Project Browser, click **Games** → **Next**
5. Select the appropriate template:
- **Blank** — Start from scratch (most flexible)
- **Third Person** — Character-based games
- **First Person** — FPS/exploration games
- **Top Down** — Strategy and arcade games
6. Choose **Blueprint** or **C++**
7. Name your project, choose a location, and click **Create**
### Step 2: Generate your project context
BMGD uses a `project-context.md` file to maintain consistency across all workflows.
In your BMad-enabled environment at the project root:
```
/bmgd-generate-project-context
```
This invokes the **Game Architect (Cloud Dragonborn)** to create a `project-context.md` file that includes:
- Project name and description
- Target platforms (PC, console, mobile)
- Engine and framework choices (Blueprint vs C++)
- Performance budgets
- Critical technical decisions
### Step 3: Run the brainstorming workflow
Define your game concept with the Game Designer agent.
```
/bmgd-brainstorm-game
```
The **Game Designer (Samus Shepard)** will guide you through:
- Selecting and combining brainstorming techniques
- Generating and refining game ideas
- Choosing a concept to develop
### Step 4: Create your Game Brief
Capture your vision and positioning.
```
/bmgd-game-brief
```
The Game Designer creates `game-brief.md` with:
- Game vision and elevator pitch
- Target audience and market positioning
- Platform and genre decisions
- Competitive analysis
- Art and audio direction
### Step 5: Design your game (GDD)
Create a comprehensive Game Design Document.
```
/bmgd-create-gdd
```
The Game Designer helps you:
- Select your game type from 24 available templates
- Define core gameplay mechanics
- Design progression systems
- Plan levels and content
- Specify art and audio requirements
Output: `gdd.md`
### Step 6: Create your technical architecture
Plan your Unreal project structure and systems.
```
/bmgd-create-architecture
```
The **Game Architect (Cloud Dragonborn)** creates `architecture.md` with:
- Project structure (Content Browser organization)
- System architecture (game framework, replication, networking)
- Unreal-specific patterns (Components, Game Instances, Gameplay Abilities)
- Performance budgets and optimization strategy
- Asset pipeline and build configuration
### Step 7: Plan your first sprint
Ready to start building? Use the Game Scrum Master to plan your work.
```
/bmgd-sprint-planning
```
The **Game Scrum Master (Max)** creates:
- `sprint-status.yaml` — Your sprint tracking file
- Stories from your GDD and Architecture
- Sprint goals and definition of done
### Step 8: Start implementing
Build features with the Game Developer agent.
```
/bmgd-dev-story [story-name]
```
The **Game Developer (Link Freeman)** helps you:
- Implement story tasks in Blueprints or C++
- Follow Unreal best practices
- Write tests for your features
- Review code before marking complete
---
## What You Get
After completing this setup, you'll have:
| File/Folder | Purpose |
|------------|---------|
| `project-context.md` | AI context for consistency across all BMGD workflows |
| `game-brief.md` | Your game's vision and positioning |
| `gdd.md` | Complete game design document |
| `architecture.md` | Technical architecture and Unreal-specific patterns |
| `sprint-status.yaml` | Sprint tracking with stories and progress |
| `stories/` | Folder containing individual story files |
---
## Unreal-Specific Considerations
### Project Structure
BMGD recommends this Content Browser structure:
```
Content/
├── Game/
│ ├── Blueprints/
│ ├── Materials/
│ ├── Meshes/
│ ├── Textures/
│ ├── Audio/
│ └── UI/
├── Developers/
│ └── [YourName]/
└── Collections/
```
### Blueprint vs C++
Your architecture should specify:
| Approach | When to Use |
|----------|-------------|
| **Blueprints** | Rapid prototyping, gameplay logic, designer-iterable systems |
| **C++** | Performance-critical systems, complex algorithms, platform-specific features |
| **Mixed** | C++ for systems, Blueprints for gameplay (common approach) |
The Game Architect will recommend the right mix for your project.
### Performance Budgets
Unreal projects typically target:
- **60 FPS** for most console/PC games
- **30 FPS** for open-world games with high draw distance
- **120 FPS** for competitive shooters
Your `architecture.md` will specify frame time budgets (ms per frame).
### Testing Setup
For Unreal automated testing, the Game QA agent (GLaDOS) can help:
```
/bmgd-test-framework
```
This sets up Unreal Automation System with:
- Unit tests (C++ and Blueprint function libraries)
- Functional tests (gameplay systems)
- Performance tests (frame rate, memory)
---
## Tips
> **Best Practice:** Always run `bmgd-generate-project-context` after creating a new Unreal project. The `project-context.md` file is the "single source of truth" that all BMGD agents reference.
> **Avoid:** Don't start with the First Person template if you're making a third-person game. Choose the template closest to your final game — the Game Architect can advise if unsure.
> **Remember:** Unreal projects are larger than Unity projects. Clean up unused content early to keep your project manageable.
---
## Common Mistakes
| Mistake | Solution |
|---------|----------|
| Skipping project-context generation | Always generate `project-context.md` first — it guides all other workflows |
Choosing the wrong template | Consult the Game Architect — starting from Blank is often cleaner than refactoring a template |
Ignoring Unreal's project structure | Follow Content Browser organization from your architecture — don't create custom folder structures |
Not using Unreal's built-in systems | Use Gameplay Abilities, Gameplay Tags, and Data Assets — don't reinvent the wheel |
---
## Next Steps
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Understand both development approaches
- **[Set up Unity with BMGD](./setup-unity.md)** — If you're considering Unity instead
- **[Run sprint planning](./sprint-planning.md)** — When you're ready to start building
- **[Agents Reference](../reference/agents.md)** — Learn about all 6 BMGD agents
# Run sprint planning with BMGD
Plan and track development sprints using BMGD's agile workflows for game development.
---
## When to Use This Guide
- You have a completed GDD and/or Architecture document
- You're ready to start implementing features
- You want to track progress through stories and sprints
---
## When to Skip This
- You're still in the design phase — complete the GDD and Architecture first
- You're doing Quick Flow prototyping — use Indie's quick-prototype instead
- You just want to test a single feature — Quick Dev is faster
---
## Prerequisites
> **Before starting:**
> - BMad Method installed with BMGD module enabled
> - Completed `gdd.md` (Game Design Document)
> - Completed `architecture.md` (Technical Architecture)
> - Basic familiarity with agile/scrum concepts
---
## Steps
### Step 1: Generate sprint status from epics
The Game Scrum Master reads your epic files to create the sprint tracking document.
```
/bmgd-sprint-planning
```
The **Game Scrum Master (Max)** will:
1. Read your GDD and Architecture documents
2. Identify epics (large feature areas)
3. Generate `sprint-status.yaml` with all stories
4. Organize stories into sprints based on dependencies and priority
### Step 2: Review your sprint status
The generated `sprint-status.yaml` includes:
```yaml
sprint: 1
status: In Progress
stories:
- id: story-001
title: "Player movement system"
status: Ready
priority: P0
points: 5
assignee: ""
- id: story-002
title: "Basic enemy AI"
status: Pending
priority: P1
points: 8
assignee: ""
```
Review the stories and adjust as needed:
- **P0** — Must have for this sprint
- **P1** — Should have if time allows
- **P2** — Nice to have, defer if needed
### Step 3: Create detailed stories
For each story, the Game Scrum Master creates a complete story file:
```
/bmgd-create-story [story-id]
```
This generates a story file in `stories/` with:
- **Title** and description
- **Acceptance criteria** — Definition of done
- **Technical notes** — From architecture
- **Test cases** — What needs to be tested
- **Dependencies** — Other stories or systems
### Step 4: Implement stories
Use the Game Developer agent to implement each story:
```
/bmgd-dev-story [story-id]
```
The **Game Developer (Link Freeman)** will:
1. Read the story file and acceptance criteria
2. Reference the architecture for technical guidance
3. Implement the feature with game-specific considerations
4. Create or update tests
5. Mark the story complete when all criteria pass
### Step 5: Review code (when flagged)
When a story is flagged "Ready for Review," use the code review workflow:
```
/bmgd-code-review
```
The Game Developer performs a clean context QA review:
- Verifies acceptance criteria are met
- Checks for performance issues
- Reviews test coverage
- Provides feedback or approves the story
### Step 6: Check sprint status
At any time, check your sprint progress:
```
/bmgd-sprint-status
```
This shows:
- Current sprint number and status
- Story progress (Ready, In Progress, Complete, Blocked)
- Risks and blockers
- Recommended next actions
### Step 7: Close the sprint
When all sprint stories are complete:
```
/bmgd-retrospective
```
The Game Scrum Master facilitates a retrospective:
- What went well
- What could be improved
- Action items for next sprint
Then run `sprint-planning` again to start the next sprint.
---
## What You Get
| File/Folder | Purpose |
|------------|---------|
| `sprint-status.yaml` | Sprint tracking with stories, progress, and risks |
| `stories/` | Folder containing individual story files |
| Each story file | Complete definition with acceptance criteria and tests |
---
## Sprint Workflow Summary
```
sprint-planning → create-story → dev-story → code-review → sprint-status → retrospective
↑_____________|
(repeat for each story)
```
---
## Tips
> **Best Practice:** Always generate stories from GDD and Architecture. Don't write stories from scratch — let the Game Scrum Master create complete drafts from your existing documentation.
> **Avoid:** Don't start implementation without stories. Stories keep you focused and provide clear acceptance criteria.
> **Remember:** Every sprint should deliver a playable increment. Test your game after each story completes.
---
## Common Mistakes
| Mistake | Solution |
|---------|----------|
| Writing stories manually | Use `bmgd-create-story` to generate complete stories from GDD/Architecture |
Starting P2 stories before P0 | Follow priority order — P0 first, then P1, then P2 |
Skipping acceptance criteria | Each story must have clear "definition of done" before implementation |
Not testing after each story | Playtest after every story completes — catches issues early |
---
## Story States
| State | Meaning | Next Action |
|-------|---------|-------------|
| **Pending** | Not yet ready to start | Move to Ready when dependencies complete |
| **Ready** | Ready to implement | Run `bmgd-dev-story` |
| **In Progress** | Currently being implemented | Complete implementation or flag if blocked |
| **Complete** | Done and tested | Move to next story |
| **Blocked** | Cannot proceed due to dependency | Resolve blocker or re-plan sprint |
---
## Next Steps
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Understand both development approaches
- **[Set up Unity/Unreal/Godot](../how-to/setup-unity.md)** — Engine-specific setup guides
- **[Agents Reference](../reference/agents.md)** — Learn about the Game Scrum Master agent
BMGD (BMad Game Development) extends BMM (BMad Method) with game-specific capabilities. This page explains the key differences.
## Quick Comparison
| Aspect | BMM | BMGD |
| -------------- | ------------------------------------- | ------------------------------------------------------------------------ |
| **Focus** | General software | Game development |
| **Agents** | PM, Architect, Dev, SM, TEA, Solo Dev | Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev |
| **Planning** | PRD, Tech Spec | Game Brief, GDD |
| **Types** | N/A | 24 game type templates |
| **Narrative** | N/A | Full narrative workflow |
| **Testing** | Web-focused | Engine-specific (Unity, Unreal, Godot) |
| **Production** | BMM workflows | BMM workflows with game overrides |
## Agent Differences
### BMM Agents
- PM (Product Manager)
- Architect
- DEV (Developer)
- SM (Scrum Master)
- TEA (Test Architect)
- Quick Flow Solo Dev
### BMGD Agents
- Game Designer
- Game Developer
- Game Architect
- Game Scrum Master
- Game QA
- Game Solo Dev
BMGD agents understand game-specific concepts like:
- Game mechanics and balance
- Player psychology
- Engine-specific patterns
- Playtesting and QA
## Planning Documents
### BMM Planning
- **Product Brief** → **PRD** → **Architecture**
- Focus: Software requirements, user stories, system design
### BMGD Planning
- **Game Brief** → **GDD** → **Architecture**
- Focus: Game vision, mechanics, narrative, player experience
The GDD (Game Design Document) includes:
- Core gameplay loop
- Mechanics and systems
- Progression and balance
- Art and audio direction
- Genre-specific sections
## Game Type Templates
BMGD includes 24 game type templates that auto-configure GDD sections:
- Action, Adventure, Puzzle
- RPG, Strategy, Simulation
- Sports, Racing, Fighting
- Horror, Platformer, Shooter
- And more...
Each template provides:
- Genre-specific GDD sections
- Relevant mechanics patterns
- Testing considerations
- Common pitfalls to avoid
## Narrative Support
BMGD includes full narrative workflow for story-driven games:
- **Narrative Design** workflow
- Story structure templates
- Character development
- World-building guidelines
- Dialogue systems
BMM has no equivalent for narrative design.
## Testing Differences
### BMM Testing (TEA)
- Web-focused (Playwright, Cypress)
- API testing
- E2E for web applications
### BMGD Testing (Game QA)
- Engine-specific frameworks (Unity, Unreal, Godot)
- Gameplay testing
- Performance profiling
- Playtest planning
- Balance validation
## Production Workflow
BMGD production workflows **inherit from BMM** and add game-specific:
- Checklists
- Templates
- Quality gates
- Engine-specific considerations
This means you get all of BMM's implementation structure plus game-specific enhancements.
## When to Use Each
### Use BMM when:
- Building web applications
- Creating APIs and services
- Developing mobile apps (non-game)
- Any general software project
### Use BMGD when:
- Building video games
- Creating interactive experiences
- Game prototyping
- Game jams
Reference for selecting and using BMGD's 24 supported game type templates.
## Overview
When creating a GDD, BMGD offers game type templates that provide genre-specific sections. This ensures your design document covers mechanics and systems relevant to your game's genre.
## Supported Game Types
### Action & Combat
#### Action Platformer
**Tags:** action, platformer, combat, movement
Side-scrolling or 3D platforming with combat mechanics. Think Hollow Knight, Celeste with combat, or Mega Man.
**GDD sections added:**
- Movement systems (jumps, dashes, wall mechanics)
- Combat mechanics (melee/ranged, combos)
- Level design patterns
- Boss design
#### Shooter
**Tags:** shooter, combat, aiming, fps, tps
Projectile combat with aiming mechanics. Covers FPS, TPS, and arena shooters.
**GDD sections added:**
- Weapon systems
- Aiming and accuracy
- Enemy AI patterns
- Level/arena design
- Multiplayer considerations
#### Fighting
**Tags:** fighting, combat, competitive, combos, pvp
1v1 combat with combos and frame data. Traditional fighters and platform fighters.
**GDD sections added:**
- Frame data systems
- Combo mechanics
- Character movesets
- Competitive balance
- Netcode requirements
### Strategy & Tactics
#### Strategy
**Tags:** strategy, tactics, resources, planning
Resource management with tactical decisions. RTS, 4X, and grand strategy.
**GDD sections added:**
- Resource systems
- Unit/building design
- AI opponent behavior
- Map/scenario design
- Victory conditions
#### Turn-Based Tactics
**Tags:** tactics, turn-based, grid, positioning
Grid-based movement with turn order. XCOM-likes and tactical RPGs.
**GDD sections added:**
- Grid and movement systems
- Turn order mechanics
- Cover and positioning
- Unit progression
- Procedural mission generation
#### Tower Defense
**Tags:** tower-defense, waves, placement, strategy
Wave-based defense with tower placement.
**GDD sections added:**
- Tower types and upgrades
- Wave design and pacing
- Economy systems
- Map design patterns
- Meta-progression
### RPG & Progression
#### RPG
**Tags:** rpg, stats, inventory, quests, narrative
Character progression with stats, inventory, and quests.
**GDD sections added:**
- Character stats and leveling
- Inventory and equipment
- Quest system design
- Combat system (action/turn-based)
- Skill trees and builds
#### Roguelike
**Tags:** roguelike, procedural, permadeath, runs
Procedural generation with permadeath and run-based progression.
**GDD sections added:**
- Procedural generation rules
- Permadeath and persistence
- Run structure and pacing
- Item/ability synergies
- Meta-progression systems
#### Metroidvania
**Tags:** metroidvania, exploration, abilities, interconnected
Interconnected world with ability gating.
**GDD sections added:**
- World map connectivity
- Ability gating design
- Backtracking flow
- Secret and collectible placement
- Power-up progression
### Narrative & Story
#### Adventure
**Tags:** adventure, narrative, exploration, story
Story-driven exploration and narrative. Point-and-click and narrative adventures.
**GDD sections added:**
- Puzzle design
- Narrative delivery
- Exploration mechanics
- Dialogue systems
- Story branching
#### Visual Novel
**Tags:** visual-novel, narrative, choices, story
Narrative choices with branching story.
**GDD sections added:**
- Branching narrative structure
- Choice and consequence
- Character routes
- UI/presentation
- Save/load states
#### Text-Based
**Tags:** text, parser, interactive-fiction, mud
Text input/output games. Parser games, choice-based IF, MUDs.
**GDD sections added:**
- Parser or choice systems
- World model
- Narrative structure
- Text presentation
- Save state management
### Simulation & Management
#### Simulation
**Tags:** simulation, management, sandbox, systems
Realistic systems with management and building. Includes tycoons and sim games.
**GDD sections added:**
- Core simulation loops
- Economy modeling
- AI agents/citizens
- Building/construction
- Failure states
#### Sandbox
**Tags:** sandbox, creative, building, freedom
Creative freedom with building and minimal objectives.
**GDD sections added:**
- Creation tools
- Physics/interaction systems
- Persistence and saving
- Sharing/community features
- Optional objectives
### Sports & Racing
#### Racing
**Tags:** racing, vehicles, tracks, speed
Vehicle control with tracks and lap times.
**GDD sections added:**
- Vehicle physics model
- Track design
- AI opponents
- Progression/career mode
- Multiplayer racing
#### Sports
**Tags:** sports, teams, realistic, physics
Team-based or individual sports simulation.
**GDD sections added:**
- Sport-specific rules
- Player/team management
- AI opponent behavior
- Season/career modes
- Multiplayer modes
### Multiplayer
#### MOBA
**Tags:** moba, multiplayer, pvp, heroes, lanes
Multiplayer team battles with hero selection.
**GDD sections added:**
- Hero/champion design
- Lane and map design
- Team composition
- Matchmaking
- Economy (gold/items)
#### Party Game
**Tags:** party, multiplayer, minigames, casual
Local multiplayer with minigames.
**GDD sections added:**
- Minigame design patterns
- Controller support
- Round/game structure
- Scoring systems
- Player count flexibility
### Horror & Survival
#### Survival
**Tags:** survival, crafting, resources, danger
Resource gathering with crafting and persistent threats.
**GDD sections added:**
- Resource gathering
- Crafting systems
- Hunger/health/needs
- Threat systems
- Base building
#### Horror
**Tags:** horror, atmosphere, tension, fear
Atmosphere and tension with limited resources.
**GDD sections added:**
- Fear mechanics
- Resource scarcity
- Sound design
- Lighting and visibility
- Enemy/threat design
### Casual & Progression
#### Puzzle
**Tags:** puzzle, logic, cerebral
Logic-based challenges and problem-solving.
**GDD sections added:**
- Puzzle mechanics
- Difficulty progression
- Hint systems
- Level structure
- Scoring/rating
#### Idle/Incremental
**Tags:** idle, incremental, automation, progression
Passive progression with upgrades and automation.
**GDD sections added:**
- Core loop design
- Prestige systems
- Automation unlocks
- Number scaling
- Offline progress
#### Card Game
**Tags:** card, deck-building, strategy, turns
Deck building with card mechanics.
**GDD sections added:**
- Card design framework
- Deck building rules
- Mana/resource systems
- Rarity and collection
- Competitive balance
### Rhythm
#### Rhythm
**Tags:** rhythm, music, timing, beats
Music synchronization with timing-based gameplay.
**GDD sections added:**
- Note/beat mapping
- Scoring systems
- Difficulty levels
- Music licensing
- Input methods
## Hybrid Game Types
Many games combine multiple genres. BMGD supports hybrid selection:
### Examples
**Action RPG** = Action Platformer + RPG
- Movement and combat systems from Action Platformer
- Progression and stats from RPG
**Survival Horror** = Survival + Horror
- Resource and crafting from Survival
- Atmosphere and fear from Horror
**Roguelike Deckbuilder** = Roguelike + Card Game
- Run structure from Roguelike
- Card mechanics from Card Game
### How to Use Hybrids
During GDD creation, select multiple game types when prompted:
```
Agent: What game type best describes your game?
You: It's a roguelike with card game combat
Agent: I'll include sections for both Roguelike and Card Game...
```
## Game Type Selection Tips
### 1. Start with Core Fantasy
What does the player primarily DO in your game?
- Run and jump? → Platformer types
- Build and manage? → Simulation types
- Fight enemies? → Combat types
- Make choices? → Narrative types
### 2. Consider Your Loop
What's the core gameplay loop?
- Session-based runs? → Roguelike
- Long-term progression? → RPG
- Quick matches? → Multiplayer types
- Creative expression? → Sandbox
### 3. Don't Over-Combine
2-3 game types maximum. More than that usually means your design isn't focused enough.
### 4. Primary vs Secondary
One type should be primary (most gameplay time). Others add flavor:
- **Primary:** Platformer (core movement and exploration)
- **Secondary:** Metroidvania (ability gating structure)
## GDD Section Mapping
When you select a game type, BMGD adds these GDD sections:
| Game Type | Key Sections Added |
| ----------------- | -------------------------------------- |
| Action Platformer | Movement, Combat, Level Design |
| RPG | Stats, Inventory, Quests |
| Roguelike | Procedural Gen, Runs, Meta-Progression |
| Narrative | Story Structure, Dialogue, Branching |
| Multiplayer | Matchmaking, Netcode, Balance |
| Simulation | Systems, Economy, AI |
## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-gds.md)** - Get started with BMGD
- **[Workflows Guide](/docs/reference/workflows/gds-workflows.md)** - GDD workflow details
- **[Glossary](/docs/reference/glossary/index.md)** - Game development terminology
# Explanation
Learn how BMad Game Dev Studio works under the hood.
---
## Development Approaches
- **[Quick Flow vs Full Production](./quick-flow-vs-full.md)** — Choose the right development path for your project
---
## Module Concepts
- **[Game Types](./game-types.md)** — Selecting and using game type templates (24 genres)
- **[BMGD vs BMM](./bmgd-vs-bmm.md)** — Understanding the differences between BMGD and core BMad Method
---
## Framework Integration
For foundational concepts about agents, workflows, and the BMad Method framework, see the [BMad Method Documentation](https://docs.bmad-method.org).
# Quick Flow vs Full Production
BMad Game Dev Studio offers two development approaches. Understanding the difference helps you choose the right path for your project.
---
## Quick Flow
**Fast iteration for solo developers and small teams.**
Quick Flow is designed for rapid prototyping and quick iteration. It's ideal when you want to test ideas fast or ship a small project quickly.
### When to Use Quick Flow
- You're working **alone** or with a **tiny team**
- You want to **test a game mechanic** before committing
- You're building a **small prototype** or game jam entry
- Speed matters more than comprehensive documentation
- You're comfortable making decisions as you go
### What Quick Flow Looks Like
```
Idea → Quick Prototype → Play → Iterate → Ship
```
**No lengthy planning phases.** You jump straight into building, test early, and refine based on what's fun.
### The Quick Flow Workflow
Quick Flow uses the **Game Solo Dev (Indie)** agent, who specializes in rapid development:
1. **Quick Prototype** — Define your core mechanic and generate a prototype structure
2. **Quick Dev** — Implement features directly with game-specific guidance
3. **Quick Spec** — Generate a technical spec when you need one (optional)
### What You Get
- A playable prototype in **hours, not days**
- Minimal documentation (just what you need)
- Fast feedback loop with playtesting
- Flexibility to pivot based on what works
### When to Skip Quick Flow
- You have a **larger team** that needs coordination
- You're working with **publishers or stakeholders** who require formal documentation
- The project needs to be **maintained long-term** by multiple developers
- You need to track **sprints, stories, and epics** formally
---
## Full Production
**Structured development for teams and long-term projects.**
Full Production follows a complete game development pipeline from concept through production. It's ideal for larger projects and teams.
### When to Use Full Production
- You have a **team** with multiple disciplines (design, code, art)
- You need **formal documentation** for stakeholders or publishers
- The project will be **maintained or expanded** over time
- You want to track progress through **sprints and stories**
- You're building something **larger than a prototype**
### What Full Production Looks Like
```
Preproduction → Design → Technical → Production (sprints/stories)
```
**Each phase has specific workflows and artifacts.** Progress is tracked through sprints, stories, and retrospectives.
### The Full Production Workflow
Full Production uses specialized agents for each phase:
| Phase | Agent | Workflows | Outputs |
|-------|-------|-----------|---------|
| **Preproduction** | Game Designer | brainstorm-game, game-brief | game-brief.md |
| **Design** | Game Designer | create-gdd, narrative | gdd.md, narrative.md |
| **Technical** | Game Architect | create-architecture, project-context | architecture.md, project-context.md |
| **Production** | Game Scrum Master | sprint-planning, create-story | sprint-status.yaml, stories/ |
| **Implementation** | Game Developer | dev-story, code-review | Completed features |
| **Testing** | Game QA | test-framework, automate | Test suites, test results |
### What You Get
- **Complete documentation** — Game brief, GDD, architecture, technical specs
- **Sprint tracking** — sprint-status.yaml with stories, progress, and risks
- **Story management** — Clearly defined features with acceptance criteria
- **Project context** — AI-aware context file for consistency across all workflows
- **Retrospective process** — Continuous improvement for the team
### When to Skip Full Production
- You're **working alone** and don't need formal process
- You just want to **test an idea quickly**
- Documentation would **slow you down** more than it helps
- The project is a **one-off prototype** or experiment
---
## Comparison at a Glance
| Aspect | Quick Flow | Full Production |
|--------|------------|-----------------|
| **Team size** | Solo or tiny team | Any size |
| **Speed** | Fast — prototype in hours | Thorough — planning takes time |
| **Documentation** | Minimal (prototype spec) | Comprehensive (brief, GDD, architecture) |
| **Tracking** | None (or informal) | Sprints, stories, retrospectives |
| **Agents involved** | Game Solo Dev (Indie) | All 6 agents as needed |
| **Best for** | Prototypes, jams, small projects | Full games, teams, publishers |
| **Time to first playable** | Hours to days | Days to weeks |
---
## Can You Switch Between Paths?
**Yes.** Quick Flow and Full Production aren't locked doors — they're different approaches to the same goal.
### Quick Flow → Full Production
Started with Quick Flow and now need more structure? No problem.
- Your prototype becomes the foundation for your **Game Brief**
- Iterate on your core mechanic in the **GDD phase**
- Use your prototype to inform the **Architecture**
The work you've done in Quick Flow informs the Full Production planning.
### Full Production → Quick Flow
In the middle of Full Production but need to test something quickly?
- Use Indie's **Quick Dev** workflow for rapid implementation
- Return to your **sprint planning** when ready
Full Production doesn't forbid Quick Flow workflows — it provides structure around them.
---
## Making Your Choice
**Still unsure?** Start with Quick Flow.
Quick Flow gets you to a playable prototype faster. If your project grows, you can transition to Full Production with your prototype as the foundation.
**Remember:** A playable prototype beats a perfect design document. Test early, ship often.
---
## Next Steps
- **[Your first game project with BMGD](../tutorials/first-game-project.md)** — Try Quick Flow now
- **[Set up Unity with BMGD](../how-to/setup-unity.md)** — Engine-specific Full Production setup
- **[Agents Reference](../reference/agents.md)** — Learn about all 6 BMGD agents
Complete reference for BMGD's six specialized game development agents.
## Agent Overview
BMGD provides six agents, each with distinct expertise:
| Agent | Name | Role | Phase Focus |
|-------|------|------|-------------|
| **Game Designer** | Samus Shepard | Lead Game Designer + Creative Vision Architect | Phases 1-2 |
| **Game Architect** | Cloud Dragonborn | Principal Game Systems Architect + Technical Director | Phase 3 |
| **Game Developer** | Link Freeman | Senior Game Developer + Technical Implementation Specialist | Phase 4 |
| **Game Scrum Master** | Max | Game Development Scrum Master + Sprint Orchestrator | Phase 4 |
| **Game QA** | GLaDOS | Game QA Architect + Test Automation Specialist | All Phases |
| **Game Solo Dev** | Indie | Elite Indie Game Developer + Quick Flow Specialist | All Phases |
## Game Designer (Samus Shepard)
### Role
Lead Game Designer + Creative Vision Architect
### Identity
Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.
### Communication Style
Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs with "Let's GOOO!"
### Core Principles
- Design what players want to FEEL, not what they say they want
- Prototype fast - one hour of playtesting beats ten hours of discussion
- Every mechanic must serve the core fantasy
### When to Use
- Brainstorming game ideas
- Creating Game Briefs
- Designing GDDs
- Developing narrative design
### Available Commands
| Command | Description |
| ---------------------- | -------------------------------- |
| `workflow-status` | Check project status |
| `brainstorm-game` | Guided game ideation |
| `create-game-brief` | Create Game Brief |
| `create-gdd` | Create Game Design Document |
| `narrative` | Create Narrative Design Document |
| `quick-prototype` | Rapid prototyping (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Architect (Cloud Dragonborn)
### Role
Principal Game Systems Architect + Technical Director
### Identity
Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
### Communication Style
Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls.
### Core Principles
- Architecture is about delaying decisions until you have enough data
- Build for tomorrow without over-engineering today
- Hours of planning save weeks of refactoring hell
- Every system must handle the hot path at 60fps
### When to Use
- Planning technical architecture
- Making engine/framework decisions
- Designing game systems
- Course correction during development
### Available Commands
| Command | Description |
| ---------------------- | ------------------------------------- |
| `workflow-status` | Check project status |
| `create-architecture` | Create Game Architecture |
| `correct-course` | Course correction analysis (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Developer (Link Freeman)
### Role
Senior Game Developer + Technical Implementation Specialist
### Identity
Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.
### Communication Style
Speaks like a speedrunner - direct, milestone-focused, always optimizing for the fastest path to ship.
### Core Principles
- 60fps is non-negotiable
- Write code designers can iterate without fear
- Ship early, ship often, iterate on player feedback
- Red-green-refactor: tests first, implementation second
### When to Use
- Implementing stories
- Code reviews
- Performance optimization
- Completing story work
### Available Commands
| Command | Description |
| ---------------------- | ------------------------------- |
| `workflow-status` | Check sprint progress |
| `dev-story` | Implement story tasks |
| `code-review` | Perform code review |
| `quick-dev` | Flexible development (IDE only) |
| `quick-prototype` | Rapid prototyping (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Scrum Master (Max)
### Role
Game Development Scrum Master + Sprint Orchestrator
### Identity
Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.
### Communication Style
Talks in game terminology - milestones are save points, handoffs are level transitions, blockers are boss fights.
### Core Principles
- Every sprint delivers playable increments
- Clean separation between design and implementation
- Keep the team moving through each phase
- Stories are single source of truth for implementation
### When to Use
- Sprint planning and management
- Creating epic tech specs
- Writing story drafts
- Assembling story context
- Running retrospectives
- Handling course corrections
### Available Commands
| Command | Description |
| ----------------------- | ------------------------------------------- |
| `workflow-status` | Check project status |
| `sprint-planning` | Generate/update sprint status |
| `sprint-status` | View sprint progress, get next action |
| `create-story` | Create story (marks ready-for-dev directly) |
| `validate-create-story` | Validate story draft |
| `epic-retrospective` | Facilitate retrospective |
| `correct-course` | Navigate significant changes |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game QA (GLaDOS)
### Role
Game QA Architect + Test Automation Specialist
### Identity
Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games on console, PC, and mobile.
### Communication Style
Speaks like a quality guardian - methodical, data-driven, but understands that "feel" matters in games. Uses metrics to back intuition. "Trust, but verify with tests."
### Core Principles
- Test what matters: gameplay feel, performance, progression
- Automated tests catch regressions, humans catch fun problems
- Every shipped bug is a process failure, not a people failure
- Flaky tests are worse than no tests - they erode trust
- Profile before optimize, test before ship
### When to Use
- Setting up test frameworks
- Designing test strategies
- Creating automated tests
- Planning playtesting sessions
- Performance testing
- Reviewing test coverage
### Available Commands
| Command | Description |
| ---------------------- | --------------------------------------------------- |
| `workflow-status` | Check project status |
| `test-framework` | Initialize game test framework (Unity/Unreal/Godot) |
| `test-design` | Create comprehensive game test scenarios |
| `automate` | Generate automated game tests |
| `playtest-plan` | Create structured playtesting plan |
| `performance-test` | Design performance testing strategy |
| `test-review` | Review test quality and coverage |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
### Knowledge Base
GLaDOS has access to a comprehensive game testing knowledge base (`gametest/qa-index.csv`) including:
**Engine-Specific Testing:**
- Unity Test Framework (Edit Mode, Play Mode)
- Unreal Automation and Gauntlet
- Godot GUT (Godot Unit Test)
**Game-Specific Testing:**
- Playtesting fundamentals
- Balance testing
- Save system testing
- Multiplayer/network testing
- Input testing
- Platform certification (TRC/XR)
- Localization testing
**General QA:**
- QA automation strategies
- Performance testing
- Regression testing
- Smoke testing
- Test prioritization (P0-P3)
## Game Solo Dev (Indie)
### Role
Elite Indie Game Developer + Quick Flow Specialist
### Identity
Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot, having shipped titles across mobile, PC, and console. Lives and breathes the Quick Flow workflow - prototyping fast, iterating faster, and shipping before the hype dies.
### Communication Style
Direct, confident, and gameplay-focused. Uses dev slang, thinks in game feel and player experience. Every response moves the game closer to ship. "Does it feel good? Ship it."
### Core Principles
- Prototype fast, fail fast, iterate faster
- A playable build beats a perfect design doc
- 60fps is non-negotiable - performance is a feature
- The core loop must be fun before anything else matters
- Ship early, playtest often
### When to Use
- Solo game development
- Rapid prototyping
- Quick iteration without full team workflow
- Indie projects with tight timelines
- When you want to handle everything yourself
### Available Commands
| Command | Description |
| ------------------ | ------------------------------------------------------ |
| `quick-prototype` | Rapid prototype to test if a mechanic is fun |
| `quick-dev` | Implement features end-to-end with game considerations |
| `quick-spec` | Create implementation-ready technical spec |
| `code-review` | Review code quality |
| `test-framework` | Set up automated testing |
| `party-mode` | Bring in specialists when needed |
### Quick Flow vs Full BMGD
Use **Game Solo Dev** when:
- You're working alone or in a tiny team
- Speed matters more than process
- You want to skip the full planning phases
- You're prototyping or doing game jams
Use **Full BMGD workflow** when:
- You have a larger team
- The project needs formal documentation
- You're working with stakeholders/publishers
- Long-term maintainability is critical
## Agent Selection Guide
### By Phase
| Phase | Primary Agent | Secondary Agent |
| ------------------------------ | ----------------- | ----------------- |
| 1: Preproduction | Game Designer | - |
| 2: Design | Game Designer | - |
| 3: Technical | Game Architect | Game QA |
| 4: Production (Planning) | Game Scrum Master | Game Architect |
| 4: Production (Implementation) | Game Developer | Game Scrum Master |
| Testing (Any Phase) | Game QA | Game Developer |
### By Task
| Task | Best Agent |
| -------------------------------- | ----------------- |
| "I have a game idea" | Game Designer |
| "Help me design my game" | Game Designer |
| "How should I build this?" | Game Architect |
| "What's the technical approach?" | Game Architect |
| "Plan our sprints" | Game Scrum Master |
| "Create implementation stories" | Game Scrum Master |
| "Build this feature" | Game Developer |
| "Review this code" | Game Developer |
| "Set up testing framework" | Game QA |
| "Create test plan" | Game QA |
| "Test performance" | Game QA |
| "Plan a playtest" | Game QA |
| "I'm working solo" | Game Solo Dev |
| "Quick prototype this idea" | Game Solo Dev |
| "Ship this feature fast" | Game Solo Dev |
## Multi-Agent Collaboration
### Party Mode
All agents have access to `party-mode`, which brings multiple agents together for complex decisions. Use this when:
- A decision spans multiple domains (design + technical)
- You want diverse perspectives
- You're stuck and need fresh ideas
### Handoffs
Agents naturally hand off to each other:
```
Game Designer → Game Architect → Game Scrum Master → Game Developer
↓ ↓ ↓ ↓
GDD Architecture Sprint/Stories Implementation
↓ ↓
Game QA ←──────────────────────────── Game QA
↓ ↓
Test Strategy Automated Tests
```
Game QA integrates at multiple points:
- After Architecture: Define test strategy
- During Implementation: Create automated tests
- Before Release: Performance and certification testing
## Project Context
All agents share the principle:
> "Find if this exists, and if it does, always treat it as the source of truth for planning and execution: `**/project-context.md`"
The `project-context.md` file (if present) serves as the authoritative source for project decisions and constraints.
## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-gds.md)** - Get started with BMGD
- **[Workflows Guide](/docs/reference/workflows/index.md)** - Detailed workflow reference
- **[Game Types Guide](/docs/explanation/game-dev/game-types.md)** - Game type templates
# BMGD Game Types Reference
BMGD's GDD workflow includes 24 game type templates. Each template provides specialized guidance for designing that specific genre.
---
## Action Games
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Action Platformer** | Jump, run, and overcome obstacles | Movement system, combat, level design patterns, ability unlocks |
| **Fighting** | One-on-one combat between characters | Move sets, combo systems, balance, frame data |
| **Shooter** | Combat through projectiles | Weapon systems, aim mechanics, enemy AI, level flow |
| **Survival** | Stay alive in a hostile environment | Resource management, crafting, base building, threat systems |
---
## Adventure & Exploration
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Adventure** | Narrative-driven exploration | Story structure, puzzles, environmental storytelling, progression |
| **Metroidvania** | Explore an interconnected world with ability-gated progression | Map design, ability gates, backtracking rewards, power curve |
| **Horror** | Evoke fear and tension | Atmosphere, threat design, resource scarcity, pacing |
| **Visual Novel** | Branching narrative with character focus | Story branches, character arcs, dialogue systems, choices |
---
## Strategy & Tactics
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Strategy** | Real-time or turn-based resource and unit management | Economy, tech trees, unit balance, map control |
| **Turn-Based Tactics** | Small-scale combat with positional strategy | Unit abilities, cover systems, action economy, mission design |
| **Tower Defense** | Defend against waves of enemies | Tower types, enemy variety, placement strategy, upgrade paths |
| **MOBA** | Team-based competitive combat with hero progression | Hero design, laning, item systems, team synergy |
---
## Role-Playing Games
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **RPG** | Character progression through story and combat | Character builds, skill trees, equipment, encounter design |
| **Roguelike** | Procedural generation with permadeath | Run structure, unlock persistence, balance across runs, item pools |
---
## Simulation & Management
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Simulation** | Model real-world systems | System depth, feedback loops, complexity management |
| **Sandbox** | Open-ended play with user creativity | Toolsets, creation tools, sharing systems, emergent gameplay |
| **Idle/Incremental** | Progress through automated systems | Prestige mechanics, balance curves, offline progression, unlock structure |
---
## Puzzle & Logic
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Puzzle** | Solve challenges using logic | Puzzle mechanics, difficulty curve, hint systems, variety |
| **Text-Based** | Gameplay through prose input | Parser design, world modeling, narrative integration, hint design |
---
## Sports & Racing
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Sports** | Simulate competitive sports | Sport rules, player stats, team AI, progression |
| **Racing** | Compete to finish first | Track design, vehicle physics, handling feel, progression |
---
## Other Genres
| Game Type | Description | Key Elements |
|-----------|-------------|--------------|
| **Card Game** | Gameplay through card mechanics | Card design, deck building, RNG management, meta evolution |
| **Party Game** | Multiplayer mini-games for social play | Minigame variety, accessibility, party size support, replayability |
| **Rhythm** | Synchronize actions to music | Beat mapping, difficulty scaling, music integration, visual feedback |
---
## Using Game Type Templates
When you run the `create-gdd` workflow, the Game Designer agent will:
1. Help you select the appropriate game type for your concept
2. Load the specialized template for that type
3. Guide you through type-specific design considerations
4. Generate a GDD tailored to your chosen genre
**Example:** If you select "Action Platformer," your GDD will include:
- Movement system design (jump mechanics, air control)
- Combat system design (attack types, combos)
- Level design patterns (platforming challenges, checkpoint placement)
- Player abilities and progression
---
## Hybrid Types
Many games combine multiple game types. The Game Designer can help you:
1. **Identify your primary type** — The core gameplay loop
2. **Select secondary types** — Systems borrowed from other genres
3. **Balance the combination** — Ensure systems work together
**Examples:**
- **Action-RPG** — Action Platformer + RPG
- **Survival Horror** — Survival + Horror
- **Rogue-lite** — Roguelike + (another genre)
- **Tower Defense RPG** — Tower Defense + RPG
---
## See Also
- **[Workflows Reference](./workflows.md)** — All BMGD workflows
- **[Agents Reference](./agents.md)** — Learn about the Game Designer agent
- **[Set up Unity/Unreal/Godot](../how-to/setup-unity.md)** — Engine-specific setup guides
# Reference
Technical documentation for BMad Game Dev Studio.
---
## Core Reference
- **[Agents](./agents.md)** — BMGD's six specialized game development agents
- **[Workflows](./workflows.md)** — Complete catalog of all BMGD workflows
- **[Game Types](./game-types.md)** — All 24 game type templates
---
## Commands Reference
| Command | Agent | Purpose |
|---------|-------|---------|
| `/bmgd-quick-prototype` | Indie | Create a rapid game prototype |
| `/bmgd-brainstorm-game` | Game Designer | Generate game ideas |
| `/bmgd-game-brief` | Game Designer | Create a project brief |
| `/bmgd-create-gdd` | Game Designer | Create a Game Design Document |
| `/bmgd-create-architecture` | Game Architect | Create technical architecture |
| `/bmgd-generate-project-context` | Game Architect | Generate project context |
| `/bmgd-sprint-planning` | Game Scrum Master | Plan and track sprints |
| `/bmgd-sprint-status` | Game Scrum Master | View sprint progress |
| `/bmgd-create-story` | Game Scrum Master | Create implementation stories |
| `/bmgd-dev-story` | Game Developer | Implement a story |
| `/bmgd-code-review` | Game Developer | Review code quality |
For the complete workflow catalog, see the [Workflows Reference](./workflows.md).
# BMGD Workflows Reference
Complete catalog of all BMad Game Dev Studio workflows organized by development phase and purpose.
---
## Quick Flow Workflows
Rapid prototyping workflows for solo developers and small teams.
| Workflow | Agent | Purpose | Prerequisites |
|----------|-------|---------|--------------|
| **quick-prototype** | Indie | Create a rapid game prototype for early validation | Game engine installed |
| **quick-dev** | Indie | Quick development iteration with game-specific guidance | Existing prototype |
| **quick-spec** | Indie | Generate a quick game specification | Game concept |
**Use when:** You want to test ideas fast, work alone, or need a playable prototype quickly.
---
## Preproduction Workflows
Define your game concept and vision before committing to production.
| Workflow | Agent | Purpose | Outputs |
|----------|-------|---------|---------|
| **brainstorm-game** | Game Designer | Generate game ideas using specialized techniques | Game concept |
| **game-brief** | Game Designer | Create a project brief capturing vision and positioning | `game-brief.md` |
**Use when:** You're starting a new project and need to define what you're building.
---
## Design Workflows
Create comprehensive game design documentation.
| Workflow | Agent | Purpose | Outputs |
|----------|-------|---------|---------|
| **create-gdd** | Game Designer | Create a Game Design Document with 24 game type templates | `gdd.md` |
| **narrative** | Game Designer | Design narrative elements and story | `narrative.md` |
**Use when:** You have a game concept and need to document the design.
**Game Type Templates Available:** Action Platformer, Adventure, Card Game, Fighting, Horror, Idle/Incremental, Metroidvania, MOBA, Party Game, Puzzle, Racing, Rhythm, Roguelike, RPG, Sandbox, Shooter, Simulation, Sports, Survival, Strategy, Text-Based, Tower Defense, Turn-Based Tactics, Visual Novel
---
## Technical Workflows
Plan your technical architecture and project structure.
| Workflow | Agent | Purpose | Outputs |
|----------|-------|---------|---------|
| **create-architecture** | Game Architect | Create game architecture with engine-specific patterns | `architecture.md` |
| **generate-project-context** | Game Architect | Create project context for AI consistency | `project-context.md` |
| **correct-course** | Game Architect | Course correction when implementation is off-track | Analysis report |
**Use when:** You need to plan how to build your game or need to get back on track.
---
## Production Workflows
Plan and track development through sprints and stories.
| Workflow | Agent | Purpose | Outputs |
|----------|-------|---------|---------|
| **sprint-planning** | Game Scrum Master | Generate sprint status from epic files | `sprint-status.yaml` |
| **sprint-status** | Game Scrum Master | View sprint progress, risks, and next actions | Status report |
| **create-story** | Game Scrum Master | Create story with ready-for-dev marking | Story file in `stories/` |
| **dev-story** | Game Developer | Implement story tasks with tests | Completed feature |
| **code-review** | Game Developer | Perform clean context QA code review | Review report |
| **retrospective** | Game Scrum Master | Facilitate retrospective after epic completion | Retrospective notes |
**Use when:** You're ready to build features, track progress, or review work.
---
## Testing Workflows
Set up and run game testing across all phases.
| Workflow | Agent | Purpose | Outputs |
|----------|-------|---------|---------|
| **test-framework** | Game QA | Initialize game test framework (Unity/Unreal/Godot) | Test project setup |
| **test-design** | Game QA | Create comprehensive game test scenarios | Test plan |
| **automate** | Game QA | Generate automated game tests | Test suite |
| **e2e-scaffold** | Game QA | Scaffold E2E testing infrastructure | E2E test framework |
| **playtest-plan** | Game QA | Create structured playtesting plan | Playtest plan |
| **performance** | Game QA | Design performance testing strategy | Performance test plan |
| **test-review** | Game QA | Review test quality and coverage | Coverage report |
**Use when:** You need to test your game, set up automation, or plan playtesting.
---
## Workflow Reference by Agent
### Game Designer (Samus Shepard)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| brainstorm-game | Preproduction | Generate and refine game ideas |
| game-brief | Preproduction | Create project brief |
| create-gdd | Design | Create Game Design Document |
| narrative | Design | Design story and narrative |
### Game Architect (Cloud Dragonborn)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| create-architecture | Technical | Create technical architecture |
| generate-project-context | Technical | Create project context |
| correct-course | Production | Course correction analysis |
### Game Developer (Link Freeman)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| dev-story | Production | Implement story tasks |
| code-review | Production | Review code quality |
| quick-dev | Quick Flow | Quick development iteration |
### Game Scrum Master (Max)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| sprint-planning | Production | Plan sprints from epics |
| sprint-status | Production | View sprint progress |
| create-story | Production | Create implementation stories |
| retrospective | Production | Facilitate retrospective |
### Game QA (GLaDOS)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| test-framework | Any | Initialize test framework |
| test-design | Any | Create test scenarios |
| automate | Any | Generate automated tests |
| e2e-scaffold | Any | Scaffold E2E testing |
| playtest-plan | Any | Plan playtesting sessions |
| performance | Any | Performance testing strategy |
| test-review | Any | Review test coverage |
### Game Solo Dev (Indie)
| Workflow | Phase | Purpose |
|----------|-------|---------|
| quick-prototype | Quick Flow | Create rapid prototype |
| quick-dev | Quick Flow | Quick development |
| quick-spec | Quick Flow | Quick specification |
---
## See Also
- **[Agents Reference](./agents.md)** — Learn about all 6 BMGD agents
- **[Quick Flow vs Full Production](../explanation/quick-flow-vs-full.md)** — Choose your development approach
- **[Game Types Reference](./game-types.md)** — All 24 game type templates