49 AI Agents Form a Game Studio: Claude Code Game Studios Brings Studio Hierarchy into a Code Session
> Source: Donchitos/Claude-Code-Game-Studios — https://github.com/Donchitos/Claude-Code-Game-Studios > Language: Shell | Stars today: 538 | License: MIT > In one line: 49 agents, 74 skills, 15 hooks — turning a Claude Code session into a game studio with hierarchy, quality gates, and QA processes.
Solo Game Dev with AI: The Bottleneck Isn't Compute, It's Structure
Open Claude Code and ask it to build a game. It writes code fast, but nothing stops you from hardcoding magic numbers, nothing checks design docs, there's no QA pass, no design review, nobody asking "does this really match the game vision?"
The bottleneck for solo AI game development isn't AI capability — it's the lack of structure. A real studio has a creative director guarding vision, a technical director managing architecture, a QA lead holding the quality gate. Claude Code gives you one general-purpose assistant with none of these roles.
Claude Code Game Studios (CCGS) solves this by moving a real studio's hierarchy into the AI session: not a stronger assistant, but 49 clearly-divided agents forming a studio with hierarchy, process, and quality gates.
Three-Tier Architecture: Directors, Department Leads, Specialists
The 49 agents are split into three tiers matching a real studio:
Tier 1 — Directors: creative-director, technical-director, producer. These three declare the Opus model in their frontmatter — most expensive, but the strongest judgment. Directors guard vision; they don't write code.
Tier 2 — Department Leads: game-designer, lead-programmer, art-director, audio-director, narrative-director, qa-lead, release-manager, localization-lead. The lead-programmer and 15 specialists declare Sonnet; the other 30 inherit your current session's model.
Tier 3 — Specialists: gameplay-programmer, engine-programmer, ai-programmer, network-programmer, tools-programmer, ui-programmer, systems-designer, level-designer, economy-designer, technical-artist, sound-designer, writer, world-builder, ux-designer, prototyper, performance-analyst, devops-engineer, analytics-engineer, security-engineer, qa-tester, accessibility-specialist, live-ops-designer, community-manager.
The author notes explicitly: treat the tiers as seniority of role, not as a billing plan. Most of the studio runs on whatever model you're already using.
74 Slash Commands Cover the Full Pipeline
CCGS isn't 49 independent agents — it's a complete workflow. 74 slash commands cover every phase from kickoff to release:
- Kickoff:
/start/brainstorm/project-stage-detect - Design:
/design-system/map-systems/propagate-design-change - Architecture:
/create-architecture/architecture-decision/architecture-review - Epics & Sprints:
/create-epics/create-stories/dev-story/sprint-plan/story-done - Reviews:
/design-review/code-review/balance-check/security-audit - QA:
/qa-plan/smoke-check/soak-test/regression-suite/test-flakiness - Release:
/release-checklist/launch-checklist/changelog/hotfix/day-one-patch - Team orchestration:
/team-combat/team-narrative/team-ui/team-release/team-polish - workflow: which GDD sections are required
- docs.density: documentation density
- qa.level: QA level
- story_granularity: story granularity
- review_mode: review mode (how many reviews)
- process: overall process weight
- CrewAI / AutoGen: agent-to-agent communication and task allocation
- CCGS: the lack of organizational structure in AI sessions
15 hooks auto-validate at commit, push, asset changes, design doc reads/writes, and session lifecycle events. 14 rules apply by path — editing gameplay code triggers gameplay rules; editing AI code triggers AI rules.
Engine Specialists: Godot, Unity, Unreal Covered
CCGS ships dedicated experts for all three major engines:
| Engine | Lead Agent | Sub-specialists | |--------|-----------|-----------------| | Godot 4 | godot-specialist | GDScript, Shaders, GDExtension | | Unity | unity-specialist | DOTS/ECS, Shaders/VFX, Addressables, UI Toolkit | | Unreal Engine 5 | unreal-specialist | GAS, Blueprints, Replication, UMG/CommonUI |
/setup-engine godot 4.7 configures the engine in one step.
Key Experiment: 29 Extra Documents Didn't Buy a Better Game
CCGS ran an honest measurement: using the same brief, it built games under both minimal and standard rigor modes and counted how many documents were written before the first line of game code:
| modes.rigor | Documents | Time | |-------------|-----------|------| | minimal | 1 (one-page brief) | 0 minutes | | standard | 30 | 58 minutes |
Result: both produced runnable, tested games. But two blind reviewers and a human playtest ranked the standard-mode game last — the 29 extra documents bought traceability, not a better game.
This is a data point worth revisiting. Intuition says "more process = better quality," but CCGS's measurement says: process buys traceability, not quality. If you're making a game solo, traceability may not be worth 58 minutes.
The "Seen It or It Doesn't Count" Principle
One CCGS design principle stands out: a story that changes anything the player sees is not closed until the game has been launched, observed, and a screenshot retained in production/qa/evidence/.
Parse checks don't count as running. Passing automated tests doesn't count as closed. Someone (or some agent) must actually launch the game, look at it, and archive a screenshot.
This principle applies even in minimal mode — automated tests can be waived, but "looking at it" cannot. Because "the menu rendered" and "the menu rendered in the visible area of the screen" are two different things.
modes.rigor: One Knob Controlling Six Dimensions
CCGS's smartest design is modes.rigor — a single switch controlling six independent dimensions:
Three levels: minimal, standard, full. In minimal mode most process is waived, but the "look at it" principle is not. This beats tuning six parameters separately — usually you just need to decide "how heavy should the process be," not configure six dimensions.
Why This Isn't "49 Agents of showing off"
Seeing 49 agents and 74 skills, your first reaction might be "this is just showing off." But look at the hierarchy: CCGS does something concrete — encoding a game studio's organizational structure into code.
The creative-director isn't writing code — it checks whether your design matches the game vision. The qa-lead isn't running tests — it decides which tests are worth running. The release-manager isn't shipping — it verifies release checklists are complete.
These roles are humans in real studios. CCGS turns them into agents, each with clear responsibilities, escalation paths, and quality gates. You still make every decision — but now a team asks you the right questions, catches mistakes early, and keeps the project organized from first brainstorm to launch.
How It Differs from Other Multi-Agent Systems
Multi-agent isn't new. CCGS's difference: it doesn't solve "how to make multiple agents collaborate" — it solves "how to give an AI session the structure of a real organization."
What 538 Stars in a Day Says
CCGS gaining 538 stars today shows the indie game dev community has an overlooked need: not stronger AI, but more structured AI sessions.
The problem with solo game development was never "the AI isn't smart enough" — it's that nobody stops you from making rookie mistakes. CCGS gives you 49 agents not to replace your thinking, but to ask you the right questions before you err.
29 documents didn't buy a better game — but they bought traceability. For a solo dev, that may not be worth it. For a team on a commercial project, it might be a lifesaver. CCGS's modes.rigor lets you decide for yourself.
---
Project: https://github.com/Donchitos/Claude-Code-Game-Studios Engine support: Godot 4 / Unity / Unreal Engine 5 License: MIT