KEEP IT HANDS-ON functional ~ tested 2026-09-23
// sandboxed in macOS (host) Β· aarch64 Β·install log Β· why not fully functional: Hooks and helper scripts were exercised end to end with positive and negative cases (commit blocking, advisory warnings, config resolution precedence, rigor expansion, legacy mirror override, enum rejection, GDD section detection). The 74 skills themselves are prompt contracts that execute inside a live Claude Code session, which this review environment cannot run, so the agent-side workflows were verified structurally only. Β·functional log

Claude Code Game Studios

by Donchitos · https://github.com/Donchitos/Claude-Code-Game-Studios · MIT · vv1.1.0 · updated 2026-09-23
Don't install your next skill blind. One email a week: what's worth installing.

The biggest game-dev skill pack we have tested, and the rare one whose hooks document their own measured performance fixes.

⚙ ⚙ ⚙ ⚙ ⚙ 4 / 5
quality 5/5
documentation 5/5
setup 4/5
value 4/5
ecosystem fit 3/5
// bottom line

This is a whole studio org chart for one Claude Code session, and it is engineered far above the norm for template repos: every counted claim in the README matched the tree exactly, all 623 internal cross-references resolve, and the hook suite survived positive and negative testing on macOS despite being developed Windows-first. Install it if you build games with Claude Code; skip it if you run any other agent, because the skills, hooks and permission rules are Claude Code shapes end to end.

Get the skill digest The best and the broken from 100+ hands-on tests. One email a week.
clone as project template
$git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game

intended install: whole template, then run /start

single skill via skills CLI
$npx skills add Donchitos/Claude-Code-Game-Studios --skill start --agent claude-code -y

lands a byte-identical SKILL.md but not the hooks and docs it references

install if

  • Solo game developers already using Claude Code. The studio hierarchy, tier-adjustable process and commit-time validation directly address the "one chat session has no structure" problem, on the exact platform the pack targets.
  • Teams prototyping in Godot, Unity or Unreal with agent assistance. The three engine specialist sets and the engine-aware code-root resolution in hooks work across all three engines from one config.
  • Agent-skill authors studying craft. The hook comments (measured starvation numbers, cross-platform fallback rationale) and the observations-not-verdicts helper discipline are among the best worked examples of production agent-tool engineering we have reviewed.

What It Does

Claude Code Game Studios (CCGS) turns a single Claude Code session into a simulated game studio: 49 subagent definitions organized as directors, department leads and specialists, 74 slash-command skills covering onboarding, design, architecture, stories, QA and release, 12 event hooks that validate commits, pushes and assets, and 13 path-scoped rule files that enforce coding standards by directory. A root project.yaml with a single modes.rigor dial (minimal, standard, full) controls how much process every skill enforces, and a bundled "CCGS Skill Testing Framework" provides rubrics and behavioral specs for testing the skills and agents themselves. The user it targets is a solo or small-team game developer building Godot, Unity or Unreal projects inside Claude Code.

The Good

Every counted claim matches the tree, exactly. README badges say 74 skills, 49 agents, 12 event hooks, 13 rules, 39 templates; the clone contains 74 SKILL.md files, 49 agent files, 14 hook scripts (12 event hooks plus a shared helper and one opt-in diagnostic), 13 rules and 39 top-level templates. The README prose claims three directors on Opus, sixteen specialists on Sonnet or Haiku and thirty agents inheriting the session model; the frontmatter tally is 3, 16 and 30. The README slash-command inventory matches the 74 skill directories with zero orphans in either direction. Version surfaces agree: git tag v1.1.0, CHANGELOG heading 1.1.0 dated 2026-09-23, and project.yaml framework.version 1.1.0.

The hook code documents its own measured performance fixes, with numbers. validate-commit.sh explains that its blocking JSON check runs before all advisory work because a 201-file commit with one corrupt file measured 730ms and rc=2 when the corrupt file sorted first, but 15217ms and a timeout (rc=124, nothing emitted) when it sorted last, so the check was moved first and batched into one Python spawn. The same file documents why stdout is written in bytes (Windows CRLF rewriting paths), why xargs uses NUL delimiters (BSD xargs rejects GNU -d, and the failure was silent on macOS, the platform the README claims to support), and why cwd precedence resolves the way it does. This is postmortem-driven code, not generated boilerplate.

The config-resolution contract holds under test, including its documented negative case. The /start skill states that modes.rigor: minimal expands to review_mode solo, but a legacy production/review-mode.txt containing lean outranks the expansion, verified against the shipped helper. We reproduced both directions: resolve_setting returned solo with provenance "rigor:minimal" on a clean fixture, and lean with provenance "production/review-mode.txt" after creating the mirror. Local overrides beat base config (solo over lean), validate_yaml_enum rejects modes.rigor: extreme with a named error, and the resolve_config prelude that skills inject at load time prints a provenance-annotated block (automation: collaborative (default), workflow: minimal (rigor:minimal), and so on).

The README publishes an unfavorable measurement about its own product. The section "Does it produce games, or documents?" counts documents written before the first line of game code at each rigor tier (1 at minimal, 30 at standard, 58 minutes) and then reports that two blind reviewers and a human playtest ranked the heavier standard build last: the extra 29 documents bought traceability, not a better game. That result is why minimal is the default. Marketing sections that argue for less process are rare in this ecosystem.

Graceful degradation is real, not claimed. With jq removed from PATH the commit, session-start and gap-detection hooks all exit 0. notify.sh, a Windows toast built on PowerShell, no-ops cleanly on macOS. The design-section advisory correctly stays silent on a fresh template because the default rigor tier requires no GDD sections, and speaks up (naming Detailed, Edge Cases and the rest) once rigor is raised to standard.

The Bad

There is no CI at all. The .github directory contains funding, codeowner and issue templates but zero workflows. A repo with 23 bash scripts and 123 YAML frontmatter blocks has nothing upstream enforcing even bash -n or a frontmatter parse; our clean structural results reflect the author's local discipline, which a single bad push could break silently. For a 25K-star project this is the largest gap we found.

Bus factor is one. The GitHub API reports a single contributor. The tree is 445 markdown files and 87,387 lines, plus hooks and helpers, maintained by one person shipping releases at high frequency (v1.1.0 landed the morning of this review).

It is Claude Code or nothing. The skills use Claude-specific frontmatter (allowed-tools, disable-model-invocation, per-skill model pins), Claude hook events and a settings.json permission block. There is no Hermes, OpenClaw or Codex path. The vercel skills CLI can install individual skills (we landed start byte-identical, with a lock hash), but a piecemeal install drops the hooks, helpers and .claude/docs tree the skill text references, so the bang-prefixed config prelude fails open to defaults. The template clone is the only complete install.

Host testing is Windows-first, by the author's own disclosure. The README states primary development happens on Windows 10 with Git Bash and that macOS and Linux "should run". Our macOS host run passed all 38 checks, which upgrades that "should", but upstream does not test the platforms it claims.

The self-test catalog ships blank. All 123 entries in the testing framework's catalog.yaml have empty last_static and last_spec result fields (the framework README says they are updated manually or via /skill-improve). The framework to audit skills exists and its spec files all resolve, but the shipped state records zero completed audits.

Small drift. The GitHub repo description says "72 workflow skills" while the tree and README say 74, and the CHANGELOG file contains only the current 1.1.0 entry, so release history lives in git tags rather than the changelog file.

Smoke Test Results

We ran three host-based passes on macOS (aarch64): a fresh clone with jq deliberately removed from PATH, a structural pass with full deps, and a functional pass against the hooks and helper scripts with positive and negative fixtures. Scripts and logs: sandbox/skills/claude-code-game-studios/.

Run A. Fresh sandbox, no deps preinstalled

$ git clone --depth 1 https://github.com/Donchitos/Claude-Code-Game-Studios (6.8 MB)
βœ… clone succeeds; LICENSE present at repo root
$ find .claude/skills -name SKILL.md | wc -l
βœ… 74 SKILL.md on disk (README badge: 74)
$ find .claude/agents -name "*.md" | wc -l
βœ… 49 agent files (README badge: 49)
$ find .claude/rules -name "*.md" | wc -l; find .claude/hooks -name "*.sh" | wc -l
βœ… 13 rule files (badge: 13) and 14 hook scripts (12 event hooks + helper + opt-in diagnostic)
$ find .claude/docs/templates -maxdepth 1 -name "*.md" | wc -l
βœ… 39 top-level templates (README badge: 39)
$ for d in .claude/skills/*/; do name-vs-dir check; done
βœ… frontmatter name matches directory for 74 of 74
$ ruby -ryaml frontmatter parse of 74 skills + 49 agents
βœ… strict YAML parse, 123 of 123 blocks, 0 broken
$ grep -c "^description:" in each skill frontmatter
βœ… description field present in 74 of 74
$ bash -n .claude/hooks/*.sh .claude/scripts/*.sh .claude/statusline.sh
βœ… syntax clean on all 23 shell scripts
$ PATH=/usr/bin:/bin bash .claude/hooks/validate-commit.sh (input: non-commit JSON, no jq)
βœ… exit 0 without jq on PATH (documented graceful degradation)
$ PATH=/usr/bin:/bin bash .claude/hooks/session-start.sh; bash .claude/hooks/detect-gaps.sh
βœ… both session hooks exit 0 without jq
$ python3 -m json.tool .claude/settings.json
βœ… settings.json is valid JSON

Pass rate: 12 of 12. The fresh tree is internally consistent and the no-jq degradation claim is verified.

Full sandbox log β†’

Run B. Sandbox with deps preinstalled

$ jq-extract hook commands from settings.json, check each script exists
βœ… 12 of 12 referenced hook scripts exist on disk
$ ruby strict-parse "CCGS Skill Testing Framework/catalog.yaml"
βœ… parses cleanly (123 entries: 74 skills + 49 agents)
$ reconcile catalog skill entries against .claude/skills dirs
βœ… exactly 74 skills + 49 agents listed, counts match the tree
$ reverse check: any skill dir or agent file missing from the catalog?
βœ… bidirectional coverage, no orphans either way
$ check each catalog spec path exists
βœ… 123 of 123 spec files exist on disk
$ path-existence check of every .claude/, docs/ and framework reference in skills, agents, CLAUDE.md
βœ… 623 references checked, 0 hard-broken (127 forward refs to files the workflow creates, classified by reading each skill's context)
$ compare README slash-command inventory against .claude/skills
βœ… 74 commands in README, 74 on disk, no orphans either direction
$ tally model: fields across 49 agent frontmatters
βœ… 3 opus + 14 sonnet + 2 haiku + 30 inherit, matching README prose exactly
$ ruby parse .claude/docs/workflow-catalog.yaml
βœ… parses with exactly 7 phases
$ bash .claude/scripts/artifact-check.sh
βœ… emits CATALOG / PHASES: 7 / STEPS: 45 denominators, exit 0
$ frontmatter scope check on .claude/rules/*.md
βœ… all 13 rule files declare a path scope

Pass rate: 11 of 11. This is the canonical install-correctness verdict: every manifest, catalog and inventory reconciles with zero drift.

Full sandbox log β†’

Run C. Functional verification (does it do what it claims?)

$ echo '{"tool_input":{"command":"git commit -m test"}}' | validate-commit.sh (invalid JSON staged in assets/data/)
βœ… exit 2, stderr names the file: "BLOCKED: assets/data/bad.json is not valid JSON"
$ same hook, valid JSON + a GDD missing required sections, rigor=standard
βœ… exit 0 with advisory warnings naming Detailed and other missing sections
$ same hook, input command "ls -la"
βœ… exit 0 immediately (passthrough for non-commit commands)
$ validate-push.sh with "git push origin main"
βœ… warns on protected-branch push
$ get_yaml_key project.yaml framework.version
βœ… returns 1.1.0
$ get_effective_yaml_key with base lean + project.local.yaml solo
βœ… returns solo (local override wins)
$ validate_yaml_enum on modes.rigor: extreme
βœ… returns 1 with a named error
$ resolve_setting modes.review_mode with rigor: minimal, no mirror
βœ… returns solo, provenance rigor:minimal (expansion contract)
$ same, after creating production/review-mode.txt containing lean
βœ… returns lean, provenance production/review-mode.txt (mirror outranks expansion, as documented)
$ resolve_config --keys automation,workflow,story_granularity,qa.level,testing.strict,system_overrides
βœ… prints the provenance-annotated config block skills inject at load time
$ gdd-structure-check.sh on a full 8-section GDD
βœ… PRESENT lists all 8, no ABSENT line
$ gdd-structure-check.sh on a stripped GDD
βœ… ABSENT lists exactly the six missing sections by name
$ project-coherence.sh
βœ… exit 0, observations only, no verdicts
$ artifact-check.sh --phase concept
βœ… 6 steps with status values
$ bash .claude/hooks/notify.sh
βœ… exit 0 on macOS (Windows-only toast, documented no-op)

Functional pass rate: 15 of 15. Both blocking and advisory paths of the commit hook behave as documented, and the entire config-resolution precedence chain (local over base, mirror over expansion, enum rejection) reproduces the contracts the skills state in prose.

Full functional log β†’

What the runs tell you

The executable half of this repo (hooks, helpers, config resolution) works as documented on a platform the author does not test, and the documentation half is self-consistent to an unusual degree. What no host run can verify is the in-session behavior of the 74 prompt-contract skills, which is the primary product; the structural evidence (623 resolving references, exact count reconciliation, spec files for every skill) is strong but indirect.

Setup Walkthrough

  1. Clone the repo as your project root: git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game && cd my-game. This is the intended install; everything else keys off the repo layout.
  2. Install Claude Code if needed (npm install -g @anthropic-ai/claude-code), then run claude in the project.
  3. Run /start. It detects project state, asks where you are (no idea, vague idea, clear concept, existing work), writes project.yaml with a modes.rigor choice, and routes you to the next skill. The default rigor is minimal, which the README justifies with the measurement described above.
  4. Recommended but optional: install jq and Python 3. Hooks fall back to grep and skip JSON validation without them; we verified the no-jq path exits cleanly.
  5. Configure your engine with /setup-engine godot 4.6 (or unity, unreal). This rewrites the engine reference import in CLAUDE.md and sets the code root (src/, Assets/, or Source/Module) that hooks and skills resolve.
  6. Adjust process weight later with /settings modes.rigor=full (team-wide) or /settings --local modes.review_mode=solo (personal, gitignored).
  7. Upgrading an existing clone: UPGRADING.md plus docs/migration-guide-v1.1.md cover the v1.0 to v1.1 config migration, including which files are safe to overwrite.

Post-install gotcha: installing individual skills via the skills CLI works and lands byte-identical files, but drops the hooks and reference docs those skills assume, so prefer the template clone unless you want a single command like /brainstorm in isolation.

Alternatives

  1. disler/super-simple-software-factory - the ADW factory pattern (deterministic Python phase scripts owning gates, agents working inside phases) for general software; prefer it when you want phase discipline without the game-studio role system.
  2. gotalab/cc-sdd - spec-driven development as agent skills across seven platforms (Claude Code, Codex, Cursor, Copilot, Windsurf, OpenCode, Gemini CLI); prefer it when cross-agent portability matters more than game-domain depth.
  3. obra/superpowers - a general cross-platform workflow skill pack with strong methodology; prefer it for non-game projects that still want structured planning and review loops.
// review provenance
reviewed by
GearScope
tested
2026-09-23 · macOS (Apple Silicon)
last verified
2026-09-23
depth
HANDS-ON
sponsorship
none, ever
// share this review
// feedback
was this review helpful?

Don't install your next skill blind.

Every week: the shortlist of skills worth installing β€” and the ones to skip β€” from 100+ hands-on tests. No spam, no affiliate links.