What is Claude Code Game Studios?

An open-source Claude Code template that turns a single Claude Code session into a coordinated AI game development studio. It includes 48 specialized agents (creative director, technical director, game designer, QA lead, narrative director, engine specialists, etc.), 37 slash commands, 8 automated hooks, 11 path-scoped coding rules, and 29 document templates — all organized into a three-tier studio hierarchy.

How does the three-tier model hierarchy work?

Directors (creative-director, technical-director, producer) run on Claude Opus — the most capable, most expensive model. Department leads (game-designer, lead-programmer, art-director, qa-lead, etc.) run on Sonnet. Specialists (gameplay-programmer, level-designer, economy-designer, qa-tester, etc.) run on Sonnet or Haiku. This maps AI capability to the type of reasoning required at each level — strategic decisions get the best model, routine implementation gets the fastest.

What are path-scoped coding rules and why do they matter?

Path-scoped rules apply different coding standards depending on which file is being edited. gameplay/ has rules around avoiding magic numbers and requiring design doc references. networking/ enforces different patterns than ui/. tests/ have their own rules. This means Claude enforces different context-appropriate standards automatically based on where it's working — without needing to be reminded in every prompt.

What do the 8 automated hooks do?

Hooks run automatically at defined moments: pre-commit validates code meets standards and catches hardcoded values before they're committed; session-start loads sprint context so every session begins with current project state; agent-invocation logs which agents were called and why (audit trail); asset-change triggers validation when art/audio files are modified. Quality gates that run without being asked.

Does this work for non-game projects?

The game studio is the implementation — the pattern is general. The three-tier model-routing strategy (strategic roles → expensive model, routine roles → fast model), path-scoped rules, automated quality gate hooks, and CLAUDE.md as org chart all transfer directly to any multi-domain project. You'd replace the game roles with whatever your domain needs.

How do I start using it?

git clone the repo, copy the .claude/ folder into your project, open Claude Code, type /start. Claude will ask about your project stage and activate the appropriate agents. Choose your engine set (Godot 4, Unity, or Unreal Engine 5) to get engine-specific specialists. The /sprint-plan command generates structured sprint tasks; /team-combat, /team-narrative, /team-ui coordinate multiple agents on a single feature.

Claude Code Game Studios: 48 Agents, Model Tiers, and CLAUDE.md as an Org Chart

By Prahlad Menon Published 2026-03-22 2 min read

Claude Code Game Studios is a 48-agent Claude Code template for game development. The game studio framing is clever. The architecture underneath it is more interesting.

The Setup

It’s a .claude/ folder. Clone the repo, copy it into your project, open Claude Code. That’s the entire install.

Inside: 48 agent definitions, 37 slash commands, 8 hooks, 11 path-scoped rules, and 29 document templates. All configured through Claude Code’s native CLAUDE.md and .claude/ structure — no separate orchestration layer, no custom API calls, no running processes.

The 247 forks out of 1,978 stars (12.5% fork rate) is notably high. Most repos sit at 5-10%. People aren’t just starring this — they’re copying it and using it.

The Part Worth Studying: Model Tiers as Org Chart

The studio hierarchy maps directly to model selection:

Tier 1 — Directors (Opus)
  creative-director  technical-director  producer

Tier 2 — Department Leads (Sonnet)
  game-designer     lead-programmer    art-director
  audio-director    narrative-director qa-lead
  release-manager   localization-lead

Tier 3 — Specialists (Sonnet / Haiku)
  gameplay-programmer  engine-programmer  ai-programmer
  network-programmer   level-designer     economy-designer
  qa-tester            sound-designer     writer  ...

Directors handle strategic decisions — vision alignment, architecture tradeoffs, scope judgment. They get Opus. Department leads own their domains and make implementation decisions. They get Sonnet. Specialists do the hands-on work with well-defined scope. They get Haiku or Sonnet.

This isn’t arbitrary. It’s a cost-optimized routing strategy encoded directly into agent definitions. The expensive model runs only for decisions that benefit from it. Routine implementation runs on the fast model. You pay for reasoning where reasoning matters and not where it doesn’t.

You don’t configure this at runtime. It’s baked into the CLAUDE.md agent definitions. The org chart is the routing table.

Path-Scoped Rules

The template includes 11 coding rules that activate based on which file is being edited:

gameplay/ — no magic numbers, design doc references required, gameplay loop validation
networking/ — different patterns, serialization standards
ui/ — accessibility rules, component conventions
tests/ — coverage requirements, naming conventions

Claude enforces the right standards for the right context automatically — without being reminded per-prompt. The rules travel with the file path, not with the conversation.

This is context-aware enforcement that doesn’t require runtime overhead. The standards are static config that Claude reads once and applies selectively.

Automated Hooks

Eight hooks run without being asked:

Hook	When It Fires	What It Does
`pre-commit`	Every commit	Validates coding standards, catches hardcoded values
`pre-push`	Every push	Final quality gate before remote
`session-start`	Session open	Loads current sprint context automatically
`agent-invocation`	Every agent call	Audit log — which agent, why, what it decided
`asset-change`	Art/audio file edits	Triggers asset validation pipeline
`gap-detection`	Periodic	Identifies missing coverage or doc gaps

The session-start hook is the most useful for solo developers. Every Claude Code session opens knowing the current sprint state, open issues, and recent decisions. No re-explaining context from scratch.

The CLAUDE.md Trend

This is the third project in a month doing something similar with CLAUDE.md as organizational infrastructure.

gstack (Garry Tan, YC) defined 8 roles — CEO, engineering manager, staff engineer, QA engineer — with specific behaviors and decision-making frames. The focus was solo-developer productivity: summon the right perspective on demand.

spec-kit (GitHub) encoded project principles, implementation plans, and task structures as persistent files. The spec becomes the source of truth; the AI implements against it rather than guessing intent.

Claude Code Game Studios goes further: it encodes an entire organizational hierarchy — delegation paths, escalation routes, quality gates, model assignments per role — as static configuration.

The pattern emerging across all three: CLAUDE.md has become the coordination layer. Not a context hint. Not a system prompt workaround. A genuine configuration substrate for how AI agents interact, what they’re responsible for, how they hand off work, and what checks they run.

Context rot — the degradation of AI coding agents as conversation history grows — is partly a structure problem. The more organizational structure you encode in static config (roles, rules, hooks, specs), the less you depend on the conversation holding that context. These projects are independently converging on the same solution.

The Pattern Is Portable

The game studio framing makes this immediately legible but also limits it in perception. The actual architecture transfers to any multi-domain project:

Replace directors/leads/specialists with whatever your domain hierarchy looks like
Replace path-scoped game rules with your domain’s file structure conventions
Keep the model-tiering strategy as-is — strategic roles → Opus, routine roles → Haiku
Keep the hooks — pre-commit validation and session-start context loading work everywhere

Someone will build “Claude Code Legal Studio” or “Claude Code Data Science Studio” using this exact structure. The game studio is the proof-of-concept that the architecture works.

→ github.com/Donchitos/Claude-Code-Game-Studios