# Claude Code Game Studios

> A game-studio template for Claude Code — 49 subagents, 73 skills, 12 hooks and path-scoped rules organised as a real studio hierarchy

- Category: Agents & Automation / Agent Skills & Plugins
- Language: Shell
- Licence: MIT
- Repository: https://github.com/Donchitos/Claude-Code-Game-Studios
- Canonical page: https://ai-tldr.dev/tools/claude-code-game-studios/

## In short

Claude Code Game Studios is a project template that gives a Claude Code session the structure of a game studio instead of one general-purpose assistant. It sits in the Agent Skills & Plugins category of the Agents & Automation tools and is open-source, written in Shell and licensed MIT. To get started: install Claude Code.

## Overview

Claude Code Game Studios is a project template that gives a Claude Code session the structure of a game studio instead of one general-purpose assistant. It ships 49 agent definitions, 73 skills exposed as slash commands, 12 hooks, 11 path-scoped rule files and 41 document templates, all as plain Markdown, YAML and bash under `.claude/`. You clone it as the starting point for a game project and drive the team from inside Claude Code.

The agents are arranged in three tiers that mirror how studios actually operate: directors (creative director, technical director, producer) guard the vision; department leads (game designer, lead programmer, art director, audio director, narrative director, QA lead, release manager, localization lead) own their domains; and specialists do the hands-on work — gameplay, engine, AI, network, tools and UI programmers, level and economy designers, technical artist, sound designer, writer, UX designer, performance analyst, DevOps, analytics, security, QA tester, accessibility specialist and more. Separate agent sets cover Godot 4, Unity and Unreal Engine 5, each with its own sub-specialists for shaders, ECS/DOTS, Blueprints, replication and UI toolkits.

The 73 skills map onto a seven-phase pipeline: onboarding (`/start`, `/project-stage-detect`, `/setup-engine`), design (`/brainstorm`, `/design-system`, `/map-systems`), architecture, stories and sprints (`/create-epics`, `/create-stories`, `/dev-story`, `/sprint-plan`), reviews (`/design-review`, `/code-review`, `/balance-check`, `/scope-check`, `/gate-check`), QA (`/qa-plan`, `/soak-test`, `/regression-suite`), production and release (`/milestone-review`, `/release-checklist`, `/patch-notes`, `/hotfix`), plus `/team-*` commands that coordinate several agents on one feature. Hooks add automation around the session — commit and asset validation, a subagent audit trail, gap detection, and state preservation across context compaction — and `settings.json` permission rules auto-allow safe operations while blocking force pushes, `rm -rf` and reads of `.env`. Everything is meant to be edited; review intensity is configurable as `full`, `lean` or `solo`. MIT-licensed.

## What it does

- 49 subagents in a three-tier studio hierarchy — directors, department leads and specialists — each with defined responsibilities and escalation paths
- 73 skills as slash commands covering the full pipeline, from /brainstorm and /design-system through /dev-story to /launch-checklist
- Engine agent sets for Godot 4, Unity and Unreal Engine 5, with sub-specialists for shaders, DOTS/ECS, GAS, Blueprints and replication
- 12 hooks that validate commits and assets, log every subagent invocation, detect missing design docs and restore session state after compaction
- 11 path-scoped rule files that enforce different standards under src/gameplay, src/core, src/ai, src/networking, src/ui, design/gdd and tests
- 41 document templates for GDDs, UX specs, ADRs, sprint plans, HUD design and accessibility
- Configurable review intensity (full / lean / solo) so the director gates can be dialled down for solo work

## Getting started

The template is a repository you clone as your game project. It needs Git and Claude Code; jq and Python 3 are optional and only improve hook validation — hooks fail gracefully without them.

1. Install Claude Code

   The template drives Claude Code's agents, skills and hooks, so the CLI is the one hard prerequisite.

```bash
npm install -g @anthropic-ai/claude-code
```

2. Clone the template as your project

   Clone it (or use it as a GitHub template) into the directory you want the game to live in.

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

3. Open a session

   Starting Claude Code in the project root loads CLAUDE.md, the agent definitions, the skills and the hooks.

```bash
claude
```

4. Run /start

   The onboarding skill asks where you are — no idea, vague concept, clear design, or existing work — and routes you to the right workflow rather than assuming.

```text
/start
```

5. Or jump straight to a phase

   If you already know what you need, call the skill directly.

```text
/brainstorm                 # explore game ideas from scratch
/setup-engine godot 4.6     # configure your engine
/project-stage-detect       # analyse an existing project
```

## When to use it

- Give a solo game project the design reviews, QA passes and quality gates a studio would provide, without hiring one
- Keep an AI-assisted codebase organised — path-scoped rules stop hardcoded values in gameplay code and allocations in hot paths
- Run a structured epic → story → dev → done loop with sprint planning and milestone reviews inside Claude Code
- Adopt an existing game project mid-flight with /project-stage-detect and /adopt instead of starting the workflow from scratch
