home / skills / supercent-io / skills-template / bmad-gds

bmad-gds skill

safe

/.agent-skills/bmad-gds

This skill guides you through a BMAD-based game development workflow, generating docs, architectures, tests, and sprint plans for multi-engine projects.

npx playbooks add skill supercent-io/skills-template --skill bmad-gds

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

5.4 KB

---
name: bmad-gds
keyword: bmad-gds
description: AI-driven Game Development Studio using BMAD methodology. Routes game projects through Pre-production, Design, Architecture, Production, and Game Testing phases with 6 specialized agents. Supports Unity, Unreal Engine, Godot, and custom engines.
allowed-tools: [Read, Write, Bash, Grep, Glob]
tags: [bmad, gds, game-development, game-design, gdd, unity, unreal, godot, multi-agent, workflow]
platforms: [Claude, Gemini, Codex, OpenCode]
version: 0.1.4
source: user-installed skill
---

# bmad-gds - BMAD Game Development Studio

## When to use this skill

- Starting a new game project and need a structured concept → production workflow
- Creating a Game Design Document (GDD), narrative design, or technical architecture
- Managing sprints and dev stories for a game team
- Setting up test frameworks for Unity, Unreal Engine, or Godot projects
- Quick prototyping or rapid feature work without full planning overhead
- Reviewing code or running retrospectives after development epics

---

## Installation

```bash
npx skills add https://github.com/supercent-io/skills-template --skill bmad-gds
```

---

## Supported Engines

Unity · Unreal Engine · Godot · Custom/Other

---

## BMAD-GDS Workflow Commands

### Phase 1 — Pre-production

| Command | Description |
|---------|-------------|
| `bmad-gds-brainstorm-game` | Facilitate a game brainstorming session with game-specific ideation techniques |
| `bmad-gds-game-brief` | Create an interactive game brief defining concept and core mechanics |

### Phase 2 — Design

| Command | Description |
|---------|-------------|
| `bmad-gds-gdd` | Generate a Game Design Document: mechanics, systems, progression, implementation guidance |
| `bmad-gds-narrative` | Create narrative documentation: story structure, character arcs, world-building |

### Phase 3 — Technical

| Command | Description |
|---------|-------------|
| `bmad-gds-project-context` | Generate project-context.md for consistent AI agent coordination |
| `bmad-gds-game-architecture` | Produce scale-adaptive game architecture: engine, systems, networking, technical design |
| `bmad-gds-test-framework` | Initialize test framework architecture for Unity, Unreal, or Godot |
| `bmad-gds-test-design` | Create comprehensive test scenarios covering gameplay, progression, and quality |

### Phase 4 — Production

| Command | Description |
|---------|-------------|
| `bmad-gds-sprint-planning` | Generate or update sprint-status.yaml from epic files |
| `bmad-gds-sprint-status` | View sprint progress, surface risks, get next action recommendation |
| `bmad-gds-create-story` | Create a dev-ready implementation story |
| `bmad-gds-dev-story` | Execute a dev story: implement tasks and tests |
| `bmad-gds-code-review` | QA code review for stories flagged Ready for Review |
| `bmad-gds-correct-course` | Navigate major in-sprint course corrections |
| `bmad-gds-retrospective` | Facilitate retrospective after epic completion |

### Game Testing

| Command | Description |
|---------|-------------|
| `bmad-gds-test-automate` | Generate automated game tests for gameplay systems |
| `bmad-gds-e2e-scaffold` | Scaffold end-to-end testing infrastructure |
| `bmad-gds-playtest-plan` | Create a structured playtesting plan for user testing sessions |
| `bmad-gds-performance-test` | Design a performance testing strategy for profiling and optimization |
| `bmad-gds-test-review` | Review test quality and coverage gaps |

### Quick / Anytime

| Command | Description |
|---------|-------------|
| `bmad-gds-quick-prototype` | Rapid prototyping to validate mechanics without full planning overhead |
| `bmad-gds-quick-spec` | Quick tech spec for simple, well-defined features or tasks |
| `bmad-gds-quick-dev` | Flexible rapid implementation for game features |
| `bmad-gds-document-project` | Analyze and document an existing game project |

---

## Specialized Agents

| Agent | Role |
|-------|------|
| `game-designer` | Game concept, mechanics, GDD, narrative design, brainstorming |
| `game-architect` | Technical architecture, system design, project context |
| `game-dev` | Implementation, dev stories, code review |
| `game-scrum-master` | Sprint planning, story management, course corrections, retrospectives |
| `game-qa` | Test framework, test design, automation, E2E, playtest, performance |
| `game-solo-dev` | Full-scope solo mode: quick prototype, quick spec, quick dev |

---

## Typical Workflow

1. Run `bmad-gds-brainstorm-game` → ideate game concept
2. Run `bmad-gds-game-brief` → lock in concept and core mechanics
3. Run `bmad-gds-gdd` → produce full Game Design Document
4. Run `bmad-gds-game-architecture` → define technical architecture
5. Run `bmad-gds-sprint-planning` → break work into sprints and stories
6. Run `bmad-gds-dev-story` per story → implement features
7. Run `bmad-gds-code-review` → quality gate before merge
8. Run `bmad-gds-retrospective` → continuous improvement after each epic

---

## Quick Reference

| Action | Command |
|--------|---------|
| Brainstorm game concept | `bmad-gds-brainstorm-game` |
| Create game brief | `bmad-gds-game-brief` |
| Generate GDD | `bmad-gds-gdd` |
| Define architecture | `bmad-gds-game-architecture` |
| Plan sprint | `bmad-gds-sprint-planning` |
| Check sprint status | `bmad-gds-sprint-status` |
| Create story | `bmad-gds-create-story` |
| Develop story | `bmad-gds-dev-story` |
| Quick prototype | `bmad-gds-quick-prototype` |

Overview

This skill is an AI-driven Game Development Studio implementing the BMAD methodology to move projects from concept through testing. It routes work through Pre-production, Design, Architecture, Production, and Game Testing phases using six specialized agents. The studio supports Unity, Unreal Engine, Godot, and custom engines and provides commands for ideation, design, architecture, sprint management, development, and QA. It is optimized for structured, repeatable game development workflows and rapid prototyping.

How this skill works

You invoke phase-specific commands to run focused agents: game-designer for concept and GDD, game-architect for technical architecture, game-dev for implementation and reviews, game-scrum-master for planning and retros, game-qa for test design and automation, and game-solo-dev for solo rapid work. Each command produces artifacts (briefs, GDDs, architecture docs, sprint files, tests, and stories) and coordinates next steps with sprint-status and project-context outputs. The skill can scaffold test frameworks, generate automated tests, and translate epics into dev-ready stories interoperable with Unity, Unreal, Godot, or custom engines.

When to use it

Starting a new game and you need a structured concept-to-production workflow
Creating or updating a Game Design Document, narrative, or technical architecture
Planning sprints, generating dev stories, and tracking sprint status
Scaffolding test frameworks and automated tests for Unity, Unreal, or Godot
Rapid prototyping or small-feature delivery without full manual overhead

Best practices

Begin with brainstorm and game-brief commands to lock concept before design or architecture
Generate project-context.md early to keep agents aligned on goals and constraints
Use sprint-planning to convert the GDD and architecture into small, testable stories
Run code-review and test-review as mandatory gates before merging features
Leverage quick-prototype and quick-dev for vertical slices to validate assumptions fast

Example use cases

Produce a full Game Design Document and narrative for a new indie title
Design a scale-adaptive network and systems architecture for a multiplayer game
Convert epics into sprint-status and dev stories, then execute implementation and tests
Scaffold end-to-end and automated tests for a Unity or Godot project
Run retrospectives after an epic to identify process improvements

FAQ

Which engines are supported?

Unity, Unreal Engine, Godot, and custom engines are supported with engine-specific scaffolding and test frameworks.

Can I use the skill for solo development?

Yes. The game-solo-dev agent provides a full-scope solo mode for rapid prototyping, quick specs, and fast implementation.