The start skill in Claude Code Game Studios is an onboarding router whose defining rule is that it will not do the work. It reads your project, asks where you are starting from, shows its assumptions, and names one next step — and it runs that step itself in exactly one case. The repository has 40,224 stars and packages 49 agents with 78 skills. It has no plugin marketplace — installation is a git clone. On skills.pub the entry skill is listed as start.
Why would an entry skill refuse to build?
Because the rest of the system depends on state that has to be collected first. The SKILL.md opens by stating what it assumes: "no game idea, no engine and no experience". It then reads the project, asks a question, and writes four settings to project.yaml — but only after an explicit yes.
| Setting | Written to | When |
|---|---|---|
project.stage | project.yaml, plus legacy mirror production/stage.txt | After confirmation |
project.goal | project.yaml | After confirmation |
modes.rigor | project.yaml | After confirmation |
modes.automation | project.yaml | After confirmation |
The exclusions matter more than the inclusions. The skill states it "never writes modes.review_mode" and none of the other knobs the rigor setting fronts — modes.workflow, docs.density, qa.level, modes.story_granularity, team.size. The reason given is precise: "a written value pins that knob over the rigor expansion, and a mirror file outranks it."
That is a skill author who has been burned by config precedence. Writing a value that should have been derived silently freezes it, and a legacy mirror file beating the new file makes the freeze invisible.
What does the allowed-tools list reveal?
The frontmatter is unusually specific:
allowed-tools: Read, Glob, Grep, AskUserQuestion, Skill,
Bash(bash .claude/scripts/project-state.sh*),
Bash(bash .claude/scripts/set-stage.sh *),
Bash(bash .claude/scripts/config-set.sh *)
model: sonnet
Three script prefixes, each with an argument wildcard, and nothing else. No general Bash, no Write, no Edit. Combined with model: sonnet — this skill runs on a cheaper model than the session — the intent is clear: onboarding is a conversation plus three idempotent state writes, and it does not need a frontier model or filesystem access.
| Restriction | Effect |
|---|---|
| Only 3 Bash prefixes | Cannot run arbitrary shell, even if the model wanted to |
No Write / Edit | Config changes must go through the helper scripts |
model: sonnet | Onboarding does not consume the session's expensive model |
Skill allowed | It can hand off to /prototype |
The last row is the escape hatch that makes the refusal work: the skill cannot write a game, but it can invoke the skill that can.
How does the handoff work?
Two cases run the next step themselves, and the SKILL.md explains why only those two:
- A game already asked for. If the opening message describes a game ("a game where you herd sheep with a dog") and the person did not type
/start, the skill asks nothing: it says in one line that it is taking them straight to the build, then starts/prototypewith no arguments. - A game brought in. If the message includes a path to an
.htmlfile or a folder, it runs/prototype --from <path>instead.
The justification is about models, not convenience: "a typed /start runs its turn on this skill's own model, and the build must run on the session's". A skill pinned to sonnet that then builds a game would build it on the wrong model. Routing through the Skill tool puts the work back on the session's model.
That is a subtlety most multi-skill repositories get wrong.
What does Phase 1 actually inspect?
It runs bash .claude/scripts/project-state.sh and keeps the rows without showing them yet — they are used to check the user's answer in the next phase rather than to interrogate them.
| Row | What it establishes |
|---|---|
engine, code_root, source_files | Whether an engine is set and how much code exists |
concept | Whether design/gdd/game-concept.md or design/game-brief.md exists |
gdd_files, adr | Design documents and architecture decisions on disk |
prototype, sprint, milestone, story | Other existing work |
origin_url | Whether the clone still points at the template repo |
Two of those rows contain defensive handling worth noting. source_files returning unknown means the code root could not be found, and the skill says to report that rather than saying "no code" — a meaningful distinction when the user believes they have code. And origin_url is matched case-insensitively against donchitos/claude-code-game-studios, because a clone that still points at the template would send a push or pull request to the upstream repository instead of the user's own fork.
That second check is a real safety guard, not a nicety.
How are the questions asked?
Through the question tool, with a stated fallback and a stated failure mode:
- "Ask with the question tool. Without one, list the options numbered and end your turn to wait."
- "The question is the last thing in the reply: no path, note or advice after it."
- "A skipped or dismissed question is not an answer: ask again in plain text."
The middle rule is about interface, not logic: trailing advice after a question makes the user answer the advice instead of the question. The third rule closes the loophole where a dismissed dialog gets read as consent.
What is the studio mode split?
The skill distinguishes two paths. The main path is "make a game (/prototype), change it after play, grow it into a project". The design documents, the agents and the team-* pipelines are "studio mode" — the path at rigor standard and full, reached in Phase 6.
So the answer to "what does this repository do" depends on where the user is. A first-time user gets one skill and a prototype. A user who says they have a shipped game and a team gets a pipeline of 49 agents. The router decides which, which is why it exists at all.
How is it installed?
There is no .claude-plugin/ directory and no marketplace manifest anywhere in the repository. Installation is a clone into a new directory, then starting Claude Code from that directory root:
git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game
cd my-game && claude
The README warns specifically against starting inside src/, because doing so "skips the project's hooks, deny rules and ask-first permission mode". That warning is worth taking literally: the hooks are in .claude/settings.json and are resolved relative to the working directory.
One prerequisite is easy to miss. The README lists Python 3 as required because the skills and hooks read project.yaml — "without it every setting silently falls back to its default". So on a machine without Python 3, /start appears to work while every configuration write it attempts quietly does nothing. That is the worst kind of failure: silent and plausible.
What should you check before using it?
- Run
bash .claude/scripts/project-state.shyourself first. Ifsource_filessaysunknown, find out why before onboarding — the skill will report it, but you will want to know whether the code root is misconfigured. - Check
origin_url. If it still points at the template, fix the remote before creating anything, or your first push goes upstream. - Confirm your harness honours
allowed-tools. If it does not restrict Bash, the three-script guard is advisory rather than enforced. - Confirm
python3 --versionworks before onboarding. Without it the settings the skill writes are ignored at read time, and the project will silently run on defaults. - Watch for a config file written during onboarding. If
modes.workfloworqa.levelappears inproject.yamlafter running/start, the skill violated its own rule and that value will now override rigor expansion.
The frontmatter, the allowed-tools list, the four written settings, the exclusion list, the two self-executing handoff cases and the project-state.sh rows were read from the repository on 2026-11-20: SKILL.md and the repository. The agent and skill counts come from the repository description; the runtime behaviour of /prototype is NOT VERIFIED here.