← Back to blog
GeneralAbout 7 min read

49 Agents, One Game

Published Nov 8, 2026
49 Agents, One Game

Claude Code Game Studios is a GitHub template that turns one Claude Code session into a 49-person game studio. 36,824 stars, MIT licensed, 49 agents, 74 slash-command skills, 15 hooks, 14 path-scoped rules, 62 document templates.

That paragraph is the version that gets shared. The version worth reading is four rows further down the README, in a section titled "Does it produce games, or documents?"

The author built four games from one brief at different process settings and counted how many documents each one wrote before the first line of game code.

At minimal, that number was one — the one-page brief — and the time was zero minutes. At standard, it was thirty documents, and fifty-eight minutes. All four builds produced a running, tested game.

Then two blind reviewers and a human playtest ranked the standard build last.

Thirty extra documents bought traceability. They did not buy a better game. Publishing that result in your own README, in a project whose entire value proposition is process, is a level of honesty I did not expect and it is the reason this piece exists.

What is actually in the box

The structure is a real studio org chart, and that is the design decision everything else follows from.

Tier one is directors: a creative director, a technical director, a producer. Tier two is department leads — game design, programming, art, audio, narrative, QA, release, localization. Tier three is twenty-odd 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.

Each one has a defined responsibility, an escalation path, and quality gates. The README's own framing is that you still make every decision, but now someone asks you the questions a studio would ask — does this fit the vision, is this number a magic constant, where is the design doc for this system.

The skills are the workflow: /start, /brainstorm, /setup-engine godot 4.7, /project-stage-detect, /design-system, /create-epics, /create-stories, /dev-story, /story-done. The hooks are validation that fires on commits, pushes, asset changes, design-doc reads, and session lifecycle. The rules are path-scoped coding standards that apply when you are editing gameplay code versus network code versus scene files.

A long meeting table surrounded by empty chairs, one document at the head

Installing it takes about a minute

Prerequisites: Git, Claude Code, Python 3, Bash, and jq if you want hook validation. On Windows, Bash comes with Git for Windows.

Then:

git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game
cd my-game
claude

Start the session in the folder that holds CLAUDE.md and project.yaml. Starting it in src/ skips the project's hooks, deny rules, and ask-first permission mode, which quietly disables most of the system.

Then run /start. It asks where you are — no idea, vague concept, clear design, existing work, and routes you. If you already know what you want, jump straight to /brainstorm or /setup-engine godot 4.7.

The one configuration decision that matters is modes.rigor: minimal, standard, or full. It is a single switch in front of six separate knobs — which GDD sections are required, document density, QA level, story granularity, and review mode. /start writes it for you.

The part I find genuinely well designed

Two mechanisms stand out.

Python is load-bearing, and the README admits it. Every skill and hook reads project.yaml through Python. If Python is missing, every setting silently falls back to its default. Hooks otherwise fail gracefully, you lose validation, nothing breaks. There is exactly one hard stop: a commit that stages data JSON will be blocked if there is no Python to validate it. That is a strange, specific, believable detail. It is what a system looks like after a year of real use.

A visual change is not done until someone looked at it. Any story that changes something the player sees cannot be closed until the game has been launched, observed, and a screenshot saved into production/qa/evidence/. A passing test is not a run. A parse check is not a run. This holds at every rigor level, including minimal, where automated tests are waived but the look is not.

That single rule does more for output quality than forty documents. Games fail visually in ways tests cannot see: a menu drawn off-screen, a sprite with the wrong pivot, a camera that clips through the floor on the second turn. Requiring a screenshot is the cheapest possible guard against the most common class of failure, and it is enforced by a hook rather than by hope.

What the 62 templates are for

Game design documents, UX specs, architecture decision records, sprint plans, HUD design, accessibility reviews. On their own, these are the paperwork nobody wants to write. Inside a system like this, they are what the agents read before acting.

That is the actual function. A document is not a deliverable here; it is the context that stops a specialist agent from inventing a magic number because it did not know the combat system's damage curve. When the art director agent needs to know whether the game is stylized or photoreal, it reads the art bible template someone filled in. Without that file, it guesses.

Which reframes the earlier measurement. Thirty documents before the first line of code is not thirty documents of value. It is a bet that the documents will be read — by the agents, on later tasks, repeatedly. When the bet pays off you get consistency. When it does not you get fifty-eight minutes of writing and a build ranked last by a blind panel.

My read is that the payoff depends entirely on whether the project lasts more than a week. Over a weekend, write one page. Over three months, write the thirty.

The upgrade path nobody mentions

Cloning a template is easy. Pulling upstream changes into a repository you have been customizing for two months is the part that hurts. Agents get edited, rules get tuned to your engine, and the next release reorganizes a directory.

The README has an upgrading section, which is more than most templates offer, and the advice that matters is to keep your own changes in a small number of predictable places, the rules files and project.yaml — so the rest can be replaced wholesale. If you fork the agents themselves, you will not be able to take updates, and the project moves quickly enough that this will matter within a release or two.

Where this pattern goes

Strip the game-specific vocabulary and what you have is a general recipe: define roles, give each role a narrow mandate, put gates between phases, and let a director agent hold the vision while specialists execute. It is the same shape as a real engineering org, and it is the same shape several teams are now building for other domains — a film crew, a marketing department, a research lab.

The honest caveat is the one the author already published. More process does not correlate with a better result, at least not at this scale, with one brief and four builds. What it correlates with is being able to explain why a decision was made three weeks later. That is worth something to a team and almost nothing to a solo jam entry.

Should you use it

If you are building a game alone and the failure you keep hitting is "I have thirty systems and no coherent vision," start at standard and see whether the questions help. If the failure you keep hitting is "I spend all my time writing docs," start at minimal — and notice that even that setting still makes the agent look at the screen before calling a story done.

The template does not make a game for you. It makes a session behave like a room full of people who have shipped before. Whether that is worth fifty-eight minutes is a question you can now answer with a measurement instead of a vibe, which is more than most AI tooling offers.

Related articles