BMGD Workflows Guide

Complete reference for all BMGD workflows organized by development phase.

Workflow Overview

BMGD workflows are organized into four phases:

BMGD Workflow Overview

Phase 1: Preproduction

Brainstorm Game

Command: brainstorm-game Agent: Game Designer Input: None required Output: Ideas and concepts (optionally saved)

Description: Guided ideation session using game-specific brainstorming techniques:

MDA Framework - Mechanics → Dynamics → Aesthetics analysis
Core Loop Workshop - Define the fundamental gameplay loop
Player Fantasy Mining - Explore what players want to feel
Genre Mashup - Combine genres for unique concepts

Steps:

Initialize brainstorm session
Load game-specific techniques
Execute ideation with selected techniques
Summarize and (optionally) hand off to Game Brief

Game Brief

Command: create-game-brief Agent: Game Designer Input: Ideas from brainstorming (optional) Output: {output_folder}/game-brief.md

Description: Captures your game’s core vision and fundamentals. This is the foundation for all subsequent design work.

Sections covered:

Game concept and vision
Design pillars (3-5 core principles)
Target audience and market
Platform considerations
Core gameplay loop
Initial scope definition

Phase 2: Design

GDD (Game Design Document)

Command: create-gdd Agent: Game Designer Input: Game Brief Output: {output_folder}/gdd.md (or sharded into {output_folder}/gdd/)

Description: Comprehensive game design document with genre-specific sections based on 24 supported game types.

Core sections:

Executive Summary
Gameplay Systems
Core Mechanics
Progression Systems
UI/UX Design
Audio Design
Art Direction
Technical Requirements
Game-Type-Specific Sections
Epic Generation (for sprint planning)

Features:

Game type selection with specialized sections
Hybrid game type support
Automatic epic generation
Scale-adaptive complexity

Narrative Design

Command: narrative Agent: Game Designer Input: GDD (required), Game Brief (optional) Output: {output_folder}/narrative-design.md

Description: For story-driven games. Creates comprehensive narrative documentation.

Sections covered:

Story Foundation (premise, themes, tone)
Story Structure (acts, beats, pacing)
Characters (protagonists, antagonists, supporting, arcs)
World Building (setting, history, factions, locations)
Dialogue Framework (style, branching)
Environmental Storytelling
Narrative Delivery Methods
Gameplay-Narrative Integration
Production Planning (scope, localization, voice acting)
Appendices (relationship map, timeline)

Narrative Complexity Levels:

Critical - Story IS the game (visual novels, adventure games)
Heavy - Deep narrative with gameplay (RPGs, story-driven action)
Moderate - Meaningful story supporting gameplay
Light - Minimal story, gameplay-focused

Phase 3: Technical

Game Architecture

Command: create-architecture Agent: Game Architect Input: GDD, Narrative Design (optional) Output: {output_folder}/game-architecture.md

Description: Technical architecture document covering engine selection, system design, and implementation approach.

Sections covered:

Executive Summary
Engine/Framework Selection
Core Systems Architecture
Data Architecture
Performance Requirements
Platform-Specific Considerations
Development Environment
Testing Strategy
Build and Deployment
Technical Risks and Mitigations

Phase 4: Production

Production workflows inherit from BMM and add game-specific overrides.

Sprint Planning

Command: sprint-planning Agent: Game Scrum Master Input: GDD with epics Output: {implementation_artifacts}/sprint-status.yaml

Description: Generates or updates sprint tracking from epic files. Sets up the sprint backlog and tracking.

Sprint Status

Command: sprint-status Agent: Game Scrum Master Input: sprint-status.yaml Output: Sprint summary, risks, next action recommendation

Description: Summarizes sprint progress, surfaces risks (stale file, orphaned stories, stories in review), and recommends the next workflow to run. Supports three modes:

interactive (default): Displays summary with menu options
validate: Checks sprint-status.yaml structure
data: Returns raw data for other workflows

Create Story

Command: create-story Agent: Game Scrum Master Input: GDD, Architecture, Epic context Output: {output_folder}/epics/{epic-name}/stories/{story-name}.md

Description: Creates implementable story drafts with acceptance criteria, tasks, and technical notes. Stories are marked ready-for-dev directly when created.

Validation: validate-create-story

Dev Story

Command: dev-story Agent: Game Developer Input: Story (ready for dev) Output: Implemented code

Description: Implements story tasks following acceptance criteria. Uses TDD approach (red-green-refactor). Updates sprint-status.yaml automatically on completion.

Code Review

Command: code-review Agent: Game Developer Input: Story (ready for review) Output: Review feedback, approved/needs changes

Description: Thorough QA code review with game-specific considerations (performance, 60fps, etc.).

Retrospective

Command: epic-retrospective Agent: Game Scrum Master Input: Completed epic Output: Retrospective document

Description: Facilitates team retrospective after epic completion. Captures learnings and improvements.

Correct Course

Command: correct-course Agent: Game Scrum Master or Game Architect Input: Current project state Output: Correction plan

Description: Navigates significant changes when implementation is off-track. Analyzes impact and recommends adjustments.

Workflow Status

Command: workflow-status Agent: All agents Output: Project status summary

Description: Checks current project status across all phases. Shows completed documents, current phase, and next steps.

Quick-Flow Workflows

Fast-track workflows that skip full planning phases. See Quick-Flow Guide for detailed usage.

Quick-Prototype

Command: quick-prototype Agent: Game Designer, Game Developer Input: Idea or concept to test Output: Working prototype, playtest results

Description: Rapid prototyping workflow for testing game mechanics and ideas quickly. Focuses on “feel” over polish.

Use when:

Testing if a mechanic is fun
Proving a concept before committing to design
Experimenting with gameplay ideas

Quick-Dev

Command: quick-dev Agent: Game Developer Input: Tech-spec, prototype, or direct instructions Output: Implemented feature

Description: Flexible development workflow with game-specific considerations (performance, feel, integration).

Use when:

Implementing features from tech-specs
Building on successful prototypes
Making changes that don’t need full story workflow

Quality Assurance Workflows

Game testing workflows for automated testing, playtesting, and quality assurance across Unity, Unreal, and Godot.

Test Framework

Command: test-framework Agent: Game QA Input: Game project Output: Configured test framework

Description: Initialize a production-ready test framework for your game engine:

Unity: Unity Test Framework with Edit Mode and Play Mode tests
Unreal: Unreal Automation system with functional tests
Godot: GUT (Godot Unit Test) framework

Creates:

Test directory structure
Framework configuration
Sample unit and integration tests
Test documentation

Test Design

Command: test-design Agent: Game QA Input: GDD, Architecture Output: {output_folder}/game-test-design.md

Description: Creates comprehensive test scenarios covering:

Core gameplay mechanics
Progression and save systems
Multiplayer (if applicable)
Platform certification requirements

Uses GIVEN/WHEN/THEN format with priority levels (P0-P3).

Automate

Command: automate Agent: Game QA Input: Test design, game code Output: Automated test files

Description: Generates engine-appropriate automated tests:

Unit tests for pure logic
Integration tests for system interactions
Smoke tests for critical path validation

Playtest Plan

Command: playtest-plan Agent: Game QA Input: Build, test objectives Output: {output_folder}/playtest-plan.md

Description: Creates structured playtesting sessions:

Session structure (pre/during/post)
Observation guides
Interview questions
Analysis templates

Playtest Types:

Internal (team validation)
External (unbiased feedback)
Focused (specific feature testing)

Performance Test

Command: performance-test Agent: Game QA Input: Platform targets Output: {output_folder}/performance-test-plan.md

Description: Designs performance testing strategy:

Frame rate targets per platform
Memory budgets
Loading time requirements
Benchmark scenarios
Profiling methodology

Test Review

Command: test-review Agent: Game QA Input: Existing test suite Output: {output_folder}/test-review-report.md

Description: Reviews test quality and coverage:

Test suite metrics
Quality assessment
Coverage gaps
Recommendations

Utility Workflows

Party Mode

Command: party-mode Agent: All agents

Description: Brings multiple agents together for collaborative discussion on complex decisions.

Advanced Elicitation

Command: advanced-elicitation Agent: All agents (web only)

Description: Deep exploration techniques to challenge assumptions and surface hidden requirements.

Standalone BMGD Workflows

BMGD Phase 4 workflows are standalone implementations tailored for game development:

workflow: '{project-root}/_bmad/bmgd/workflows/4-production/dev-story/workflow.yaml'

This means:

BMGD workflows are self-contained with game-specific logic
Game-focused templates, checklists, and instructions
No dependency on BMM workflow files

Next Steps

Quick Start Guide - Get started with BMGD
Quick-Flow Guide - Rapid prototyping and development
Agents Guide - Agent reference
Game Types Guide - Game type templates