Build an Indie Game in 5 Days with Claude Code Game Studios’ 49 AI Agents

The author presents Claude Code Game Studios, a virtual game‑studio framework that combines 49 specialized AI agents, 72 slash commands, and 12 automation hooks to cover the full pipeline from concept to release.

Recommended Reasons

Professional studio structure – a three‑tier hierarchy that mirrors real studios (director, department leads, specialists).

72 skill commands – each command implements a complete workflow, e.g., /brainstorm, /design-system, /create-epics, /dev-story, etc.

Automated quality assurance – 12 hooks validate commits, assets, and session state, keeping the project on track.

Core Features

Feature 1: 49 Specialized Agents

Agents are organized in a three‑tier structure:

Tier 1 — Director layer (Opus model)
  ├── creative-director
  ├── technical-director
  └── producer

Tier 2 — Department lead layer (Sonnet model)
  ├── game-designer
  ├── lead-programmer
  ├── art-director
  ├── audio-director
  ├── narrative-director
  ├── qa-lead
  └── release-manager

Tier 3 — Specialist layer (Sonnet/Haiku model)
  ├── gameplay-programmer
  ├── engine-programmer
  ├── ai-programmer
  ├── network-programmer
  ├── ui-programmer
  ├── systems-designer
  ├── level-designer
  ├── technical-artist
  ├── sound-designer
  ├── writer
  └── ... (total 49)

Each agent has a clear responsibility boundary and an upgrade path, preventing overreach.

Feature 2: 72 Skill Commands

The slash commands span the entire game‑development lifecycle. Examples include: /brainstorm – uses the MDA framework to explore game concepts. /design-system – writes GDD sections. /create-architecture – generates architecture documents and ADR list. /create-epics and /create-stories – translate GDD into executable tasks. /dev-story – implements a story. /qa-plan, /smoke-check, /test-setup – testing workflow. /team-combat, /team-ui, /team-qa – coordinate multiple agents.

Feature 3: 12 Automation Hooks

Hooks run automatically at specific moments: validate-commit.sh – before commit, checks hard‑coded values, TODO format, JSON validity. validate-assets.sh – after asset write, validates naming conventions and JSON structure. detect-gaps.sh – at session start, detects project gaps and suggests next steps. log-agent.sh – on agent start, records audit trace. session-stop.sh – on session end, archives session state.

Feature 4: 11 Path‑Based Rules

File‑path patterns automatically enforce coding standards, for example: src/gameplay/** – enforces data‑driven values and disables UI references. src/core/** – ensures hot‑path zero allocation and thread safety. design/gdd/** – requires eight mandatory chapters and formula formatting. tests/** – enforces naming conventions and coverage requirements.

Practical Scenarios

Scenario 1: Designing a New Game from Scratch

Requirement: a vague idea such as “space exploration + survival”. The framework guides the user through onboarding ( /start with “A) No idea yet”), brainstorming ( /brainstorm open), applying the MDA framework, self‑determination theory, and generating a game‑pillar document. Subsequent steps configure the engine ( /setup-engine), define visual style ( /art-bible), map systems ( /map-systems), design each MVP system ( /design-system), and review GDD consistency ( /review-all-gdds). The output includes structured GDD files and system indexes, reducing concept work from two weeks to 2‑3 days.

Scenario 2: Implementing a New Feature (Combat System)

Requirement: add a combat system. The workflow checks for an existing combat GDD ( /design-system combat), creates an epic ( /create-epics combat), splits it into stories ( /create-stories combat), develops each story ( /dev-story production/epics/combat/story-001.md), runs code review ( /code-review src/combat/), and marks the story complete ( /story-done production/epics/combat/story-001.md).

Installation

Requirements: Node.js ≥ 18.x, Git, Claude Code CLI ( npm install -g @anthropic-ai/claude-code), plus jq and Python 3 for hook validation.

Installation commands:

# Option 1: use as a template
git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game
cd my-game

# Option 2: clone then start
claude
# then run /start for onboarding

Testing

A quick test generated a 2048‑style mini‑game in a single sentence.

Technical Architecture

The repository layout includes .claude/ for settings, agents, skills, hooks, rules, and documentation; design/ for GDD, art, UX; src/ for game source code; prototypes/ for one‑off prototypes; and tests/ for test suites.

The seven‑phase workflow is:

concept – brainstorming and engine setup.

systems-design – GDD authoring.

technical-setup – architecture decisions.

pre-production – UX specs and prototype validation.

production – sprint development.

polish – performance tuning and balance.

release – launch preparation.

Agent Coordination Protocol

Requests flow from the user to a Director (Opus) for strategic decisions, then to Department Leads (Sonnet) for department‑level choices, and finally to Specialists (Sonnet/Haiku) for implementation. Collaboration principles include vertical delegation, horizontal consultation, conflict escalation, and cross‑department change propagation coordinated by the Producer.

Project Highlights

Methodology‑driven – based on MDA, self‑determination theory, and flow theory.

Real studio structure – mirrors actual game‑studio hierarchy.

Automated quality assurance – hooks keep the project on track.

Comprehensive documentation – 39 templates cover all necessary docs.

Engine‑agnostic – supports Godot, Unity, and Unreal.

Reference

Project repository: https://github.com/Donchitos/Claude-Code-Game-Studios