Claude Skills Collection Logo
Back to notes

NOTES / GUIDES

Claude Code Game Studios Uses 75 Skills and One That Refuses to Build

Its /start skill deliberately will not build your game. It reads project state, asks what you have, then hands off to /prototype on the session's model.

6 min read

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.

SettingWritten toWhen
project.stageproject.yaml, plus legacy mirror production/stage.txtAfter confirmation
project.goalproject.yamlAfter confirmation
modes.rigorproject.yamlAfter confirmation
modes.automationproject.yamlAfter 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.

RestrictionEffect
Only 3 Bash prefixesCannot run arbitrary shell, even if the model wanted to
No Write / EditConfig changes must go through the helper scripts
model: sonnetOnboarding does not consume the session's expensive model
Skill allowedIt 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 /prototype with no arguments.
  • A game brought in. If the message includes a path to an .html file 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.

RowWhat it establishes
engine, code_root, source_filesWhether an engine is set and how much code exists
conceptWhether design/gdd/game-concept.md or design/game-brief.md exists
gdd_files, adrDesign documents and architecture decisions on disk
prototype, sprint, milestone, storyOther existing work
origin_urlWhether 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?

  1. Run bash .claude/scripts/project-state.sh yourself first. If source_files says unknown, find out why before onboarding — the skill will report it, but you will want to know whether the code root is misconfigured.
  2. Check origin_url. If it still points at the template, fix the remote before creating anything, or your first push goes upstream.
  3. Confirm your harness honours allowed-tools. If it does not restrict Bash, the three-script guard is advisory rather than enforced.
  4. Confirm python3 --version works before onboarding. Without it the settings the skill writes are ignored at read time, and the project will silently run on defaults.
  5. Watch for a config file written during onboarding. If modes.workflow or qa.level appears in project.yaml after 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.

Sources