Building a game alone with AI is easy to start and hard to keep organized. One chat session has no design review, no QA pass, and nobody asking whether a new feature fits the game's vision. Claude Code Game Studios is an open source template that tries to fix that by turning a single Claude Code session into a small, organized studio: 49 specialist agents, 74 slash-command skills, 15 hooks, and 14 path-scoped rules, arranged the way a real studio is arranged.
Key Takeaways
>
Claude Code Game Studios is a free, MIT-licensed project template, not a game engine and not a product made by Anthropic. You clone it, open Claude Code in its root folder, and its files under `.claude/` shape how the session works.
It organizes 49 agents into three tiers: 3 directors, 8 department leads, and the rest specialists, with separate agent sets for Godot 4, Unity, and Unreal Engine 5.
The workflow runs through slash commands such as `/start`, `/brainstorm`, `/create-stories`, `/dev-story`, and `/story-done`, with a `modes.rigor` setting that controls how much process each story carries.
At the time of writing it has 32,807 stars and 4,454 forks on GitHub, and version 1.2.0 is the current release line.
The project's own test is refreshingly honest: the most process-heavy build wrote 30 documents before its first line of game code and was ranked last by blind reviewers and a human playtest.
It does not ship a sample game. It is a starting template for your own game, and Claude Code usage itself is still paid.
Watch the 30-second repo signal
What It Actually Is
Claude Code Game Studios, by Donchitos, describes itself as a way to turn a single Claude Code session into a full game development studio. That wording is worth unpacking, because the project is configuration, not magic. It contains agent definitions, skill files, hooks, rules, and document templates. It does not contain a game, and it does not replace Claude Code, your engine, or your judgement.
The problem it targets is stated plainly in its README: a solo developer using AI has no structure. Nobody stops you from hardcoding magic numbers, skipping design docs, or writing spaghetti code. The template answers that with roles. Directors guard the vision, department leads own their domains, and specialists do the hands-on work, each with defined responsibilities, escalation paths, and quality gates.
It is also explicitly collaborative, not autonomous. The README says you still make every decision, while the team asks the right questions, catches mistakes early, and keeps the project organized from first brainstorm to launch. That is an important distinction in a field full of tools that promise to build a game while you sleep. This one promises a better organized session, with you in charge.
The Studio Hierarchy
The 49 agents sit in three tiers, matching how real studios operate, according to the README:
Tier | Roles | Examples |
|---|---|---|
Tier 1, Directors | 3 | creative-director, technical-director, producer |
Tier 2, Department Leads | 8 | game-designer, lead-programmer, art-director, audio-director, narrative-director, qa-lead, release-manager, localization-lead |
Tier 3, Specialists | The rest | gameplay-programmer, engine-programmer, ai-programmer, level-designer, sound-designer, qa-tester, accessibility-specialist, and more |
One practical detail matters for cost. The three directors ask for Opus, the lead-programmer and fifteen specialists name Sonnet, and the remaining thirty inherit your session's model. Treat the tiers as seniority of role, not as a billing plan, the README says, since most of the studio runs on whatever model you are already using.
There are also engine-specific agent sets. Godot 4 gets a godot-specialist with GDScript, shaders, and GDExtension coverage. Unity gets a unity-specialist covering DOTS/ECS, shaders and VFX, Addressables, and UI Toolkit. Unreal Engine 5 gets an unreal-specialist covering GAS, Blueprints, replication, and UMG/CommonUI. Version 1.2.0 references Godot 4.7, Unreal Engine 5.8, and Unity 6.3 LTS, according to its release notes.
What Is Included
Component | Count | What it does |
|---|---|---|
Agents | 49 | Specialized subagents across design, programming, art, audio, narrative, QA, and production |
Skills | 74 | Slash commands for every workflow phase, from `/start` to `/hotfix` |
Hooks | 15 | Automated validation on commits, pushes, asset changes, design-doc reads and writes, session lifecycle, and gap detection |
Rules | 14 | Path-scoped coding standards enforced when editing gameplay, engine, AI, UI, network code, scene files, and asset files |
Templates | 62 | Document templates for game design documents, UX specs, architecture decision records, sprint plans, HUD design, accessibility, and more |
A small counting note, because it shows up if you search: the repo's short GitHub description says 72 skills, while the README's own table says 74. This article uses the README figure, which independent write-ups such as DigiSoulHub also use, and which matches the skill files in the current release.
How a Game Moves Through It
The main path starts with `/start`. The system asks where you are, whether you have no idea, a vague concept, a clear design, or existing work, and guides you to the right workflow. From there, `/brainstorm` explores ideas, `/design-system` and `/create-architecture` shape the design, `/create-epics` and `/create-stories` break it into work, `/dev-story` builds one story, and `/story-done` checks it against its scope and evidence.
The single setting that matters most is `modes.rigor` in `project.yaml`, with three levels:
Rigor level | What it means | Best for |
|---|---|---|
minimal | No game design documents required, terse docs, minimal QA evidence, solo review | Jam games and fast prototypes |
standard | 5 required game design document sections, balanced doc depth, standard QA evidence, lean review | A serious indie project |
full | All 8 game design document sections, thorough docs, full QA evidence on every story type, full director review | A production with traceability needs |
Two escape hatches keep that setting from being blunt. System overrides hold a single system, such as combat, to a higher standard than the rest of the project, and testing strictness can be set per test type, so a missing evidence item blocks a story for logic tests but only warns for another type.
The QA rule that stands out most is visual. A story that changes anything the player sees is not closed until the game has been launched, observed, and a screenshot retained as evidence. A passing test says nothing about a menu drawn off-screen, the README argues, so a parse check is not a run. At every rigor level, including minimal, where automated tests are waived, the look is not.
The Honest Catch: More Process Is Not Always Better
Most AI tool READMEs hide their weak results. This one leads with its own. Four games were built from one brief at different rigor levels, and the documents each wrote before its first line of game code were counted. Minimal wrote 1, the one-page brief, in 0 minutes. Standard wrote 30, in 58 minutes. All of them produced a running, tested game. Two blind reviewers and a human playtest then ranked the standard build last. The extra 29 documents bought traceability, not a better game.
That is why minimal is the default. The README says the heavier tier costs more to reach working code without producing a better result, and gives nothing back when someone new picks the project up. Raise the rigor in one `/settings` call when the project grows, it advises, not before.
An independent hands-on test adds a second caveat. AI Parabellum, testing with Claude Code and Godot, found both of its test games worked, with a written brief, small stories, screenshots as proof, and a cleaner code layout, but also found that at minimal rigor the 49 agents did not actually run: Claude wrote the code itself and skipped the programmer agent and the Godot specialist's check. The lesson is consistent with the README's own finding. The studio structure helps most when you actually turn the rigor up, and at the lightest setting you are mostly getting a cleaner workflow, not 49 agents at work.
How to Try It
Prerequisites are Git, Claude Code, Python 3, and Bash, with jq recommended for hook validation. The README gives this setup:
``` git clone https://github.com/donchitos/claude-code-game-studios.git my-game cd my-game ```
Then open Claude Code in the project's root folder, the one holding `CLAUDE.md` and `project.yaml`, and start a session:
``` claude ```
From there, run `/start`. One warning from the README is worth following exactly: starting Claude Code in a subfolder such as `src/` skips the project's hooks, deny rules, and ask-first permission mode. Always start at the root.
It is also worth remembering what this template is not. It is not made by Anthropic, it does not include engine licenses or Claude Code subscription costs, and it does not ship art, audio, or a finished game. If you are evaluating it as open source infrastructure for your own workflow, that is the right frame: a free, MIT-licensed way to organize AI-assisted game development, with real process costs you should measure on your own project.
Frequently Asked Questions
Does Claude Code Game Studios build a game by itself?
No. It is a template of agents, skills, hooks, and templates that organizes a Claude Code session. You make the decisions, and the agents ask questions, draft, review, and check work. It is collaborative by design, not autonomous.
Which engines does it support?
Godot 4, Unity, and Unreal Engine 5, each with its own specialist agent set. Version 1.2.0 references Godot 4.7, Unreal Engine 5.8, and Unity 6.3 LTS.
Is it free?
The template itself is free under the MIT license. Claude Code usage is paid separately, and heavier rigor levels use more model calls, so a full-rigor project costs more than a minimal one.
Does it ship a sample game?
No, deliberately. The README says somebody else's game in your repo is clutter, not evidence. You clone the template to start your own project.
Should I use minimal, standard, or full rigor?
Start with minimal, the default. The project's own test found the standard build, with 30 documents before its first line of code, ranked last by reviewers and a playtest. Raise rigor when your project grows and traceability starts to matter more than speed.
Claude Code Game Studios is an unusually honest AI tool: it gives a solo developer the structure of a studio, then warns, in its own README, that too much of that structure can hurt. If you have felt the chaos of an unstructured AI coding session, with no design review and no one checking whether the game actually looks right, this template is worth a weekend trial. Start minimal, keep the screenshot rule, and let the project earn its process before you turn the rigor up.