Rodent Defense — a tower defense prototype built entirely using this toolkit and Claude Code.
What Is This?
Building a game solo with AI is powerful, but a single chat has no structure. No one stops you from hardcoding magic numbers, skipping design docs, or writing spaghetti code. There’s no QA pass, no design review, no one asking “does this actually fit the game’s vision?”
Claude Unity Game Studio gives your AI session the structure of a real game studio. Instead of one general-purpose assistant, you get 49 specialized AI agents organized into a studio hierarchy — directors who guard the vision, leads who own their domains, and specialists who do the hands-on work. Each agent has defined responsibilities, escalation paths, and quality gates.
You still make every decision. But now you have a team that asks the right questions, catches mistakes early, and keeps your project organized from first brainstorm to launch.
Table of Contents
What’s Inside
This toolkit combines five specialized components into one cohesive system:
| Component |
What It Provides |
Count |
| Game Studios Template |
Studio hierarchy, agents, skills, hooks, rules, templates |
49 agents, 72 skills, 12 hooks, 11 rules |
| Unity Knowledge Skills |
Deep Unity 6.3 LTS API knowledge across every subsystem |
35 skills (95 files, 44,500+ lines) |
| Unity Middleware Skills |
Production middleware expertise (VContainer, UniTask, Wwise, etc.) |
21 skills |
| Unity AI Workflow |
Simplified workflow commands with game-feel-first philosophy |
9 commands, 13 skills |
| Unity MCP |
Real-time bridge between Claude Code and Unity Editor |
MCP server + C# plugin |
Total: 49 agents, 120+ skills, 12 hooks, 11 coding rules, 39 document templates.
How It Works
When you open a Claude Code session in your game project, the system loads automatically:
Claude Code Session Opens
|
+-> Loads CLAUDE.md (master instructions for the AI)
|
+-> Auto-discovers 49 agents (directors, leads, specialists)
| Each knows its domain, responsibilities, and escalation paths
|
+-> Auto-discovers 120+ skills (slash commands)
| From brainstorming to launch checklists
|
+-> Loads Unity knowledge plugins
| 35 API skills + 21 middleware skills = deep engine expertise
|
+-> Activates 12 hooks
| Automated validation on commits, pushes, session lifecycle
|
+-> Ready for you to say: "/start"
From there, you drive. The AI asks questions, proposes options, and waits for your decisions. It never writes code without approval. It never skips design docs. It never pushes without your say-so.
Prerequisites
Before starting, you need:
-
Claude Code — Anthropic’s CLI tool for AI-assisted development
# Install Claude Code
npm install -g @anthropic-ai/claude-code
# Verify installation
claude --version
You’ll need an Anthropic API key or a Claude Pro/Max subscription.
-
Unity — You must install Unity to build and run your game. This toolkit helps Claude Code write Unity code for you, but the actual game runs in the Unity Editor.
- Download and install Unity Hub (free — works on Windows, macOS, and Linux)
- Create a free Unity account if you don’t have one (Personal license is free)
- In Unity Hub, click Installs > Install Editor and install Unity 6.3 LTS (recommended) or any Unity 6.x version
- When creating a new project, choose a template (e.g., 3D Core or 2D Core) and save it inside your game workspace folder
The toolkit works with Unity 2022+ but the knowledge skills target Unity 6.3 LTS APIs specifically. If you use an older version, some API references may differ.
-
Git — For version control
git --version # Should be 2.x+
-
Node.js (optional) — Only needed for the Unity MCP bridge
node --version # 18+ recommended
Quick Start (5 Minutes)
Option A: Fresh Game (Recommended for First-Timers)
# 1. Clone this repo
git clone https://github.com/IdoCohen560/claude-unity-game-studio.git
# 2. Create your game workspace
mkdir MyGame && cd MyGame
# 3. Run the setup script
bash ../claude-unity-game-studio/setup.sh
# 4. Create your Unity project inside the workspace
# Open Unity Hub -> New Project -> save as MyGame/MyGameUnity/
# 5. Open Claude Code in your workspace
claude
# 6. Start the guided onboarding
# Type: /start
Option B: Copy Into Existing Project
# 1. Clone this repo
git clone https://github.com/IdoCohen560/claude-unity-game-studio.git
# 2. Copy the toolkit into your project root
cp -r claude-unity-game-studio/game-studios-template/.claude/ ./your-project/.claude/
cp claude-unity-game-studio/game-studios-template/CLAUDE.md ./your-project/CLAUDE.md
# 3. Add Unity knowledge plugins
claude --plugin-dir claude-unity-game-studio/unity-knowledge-skills
claude --plugin-dir claude-unity-game-studio/unity-middleware-skills
# 4. Open Claude Code in your project
cd your-project && claude
# 5. Run the adoption workflow
# Type: /adopt
Option C: Manual Setup (Full Control)
See SETUP.md for detailed manual installation instructions.
Setup Options
Minimal (Just the Studio)
Copy only the game-studios-template/ contents. You get 49 agents, 72 skills, and the full studio hierarchy. No Unity-specific knowledge plugins.
Standard (Recommended)
Studio + Unity Knowledge Skills + Unity Middleware Skills. This is the sweet spot for most Unity developers. Copy the template and load the two plugins.
Full (Everything)
All components including the Unity AI Workflow wrapper and Unity MCP bridge. Best for developers who want the complete experience with real-time Unity Editor integration.
Your First Game: A Complete Walkthrough
Here’s what a full game development session looks like with this toolkit:
Phase 1: Ideation
You: /start
AI: Welcome! I see no engine configured and no game concept.
Where are you starting from?
1. No idea yet — let's brainstorm
2. Vague idea — help me develop it
3. Clear concept — let's design systems
4. Existing project — help me organize it
You: 1
AI: /brainstorm
Let's explore. What kind of experience excites you?
[Guided ideation using MDA framework, player psychology...]
>>> After 10-15 minutes of conversation <<<
AI: Here's your game concept. May I write this to design/game-concept.md?
- Title: "Ember Hollow"
- Genre: Action-roguelike
- Core Fantasy: "Master elemental combinations to survive"
- 3 Design Pillars: Discovery, Mastery, Expression
Phase 2: Design
You: /map-systems
AI: Based on your concept, I've identified 8 core systems:
1. Combat System (melee + ranged + elemental)
2. Element Combination System
3. Procedural Level Generation
4. Progression / Unlocks
5. Enemy AI
6. UI / HUD
7. Audio / Music
8. Save System
Want me to design each one? I'll create GDDs with the 8 required sections.
You: Start with Combat
AI: [Asks detailed questions about combat feel, pacing, complexity...]
[Produces a complete GDD with formulas, edge cases, tuning knobs]
May I write this to design/gdd/combat-system.md?
Phase 3: Architecture
You: /create-architecture
AI: [Reads all GDDs, proposes architecture decisions]
[Creates ADRs for: state management, event bus, DI approach, etc.]
You: /gate-check concept
AI: [4 directors review in parallel]
Creative Director: READY — pillars are strong
Technical Director: CONCERNS — one API needs verification
Producer: READY — scope is feasible
Art Director: READY — visual identity anchor prepared
Result: CONCERNS (1 item to resolve before proceeding)
Phase 4: Implementation
You: /create-epics
AI: [Breaks architecture into 5 epics]
You: /create-stories combat-epic
AI: [Breaks combat epic into 12 stories with acceptance criteria]
You: /dev-story stories/combat-01-hitbox-detection.md
AI: [Spawns gameplay-programmer agent]
[Agent reads story, GDD, ADRs, control manifest]
[Implements with tests, asks before every file write]
[Reports: COMPLETE with 4/4 acceptance criteria met]
You: /story-done stories/combat-01-hitbox-detection.md
AI: [Validates all criteria, records completion, surfaces next story]
Phase 5: Polish & Ship
You: /team-polish combat
AI: [Spawns performance-analyst + technical-artist + sound-designer + qa-tester]
[Each reviews the combat system from their domain]
[Returns: optimization opportunities, VFX suggestions, audio gaps, bugs]
You: /gate-check release
AI: [Full director review for release readiness]
[Launch checklist generated]
The Studio Hierarchy
Agents are organized into three tiers, matching how real game studios operate:
Tier 1 — Directors (Opus model — strategic decisions)
creative-director technical-director producer art-director
Tier 2 — Department Leads (Sonnet model — domain ownership)
game-designer lead-programmer audio-director
narrative-director qa-lead release-manager
localization-lead ux-designer
Tier 3 — Specialists (Sonnet/Haiku model — hands-on work)
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 prototyper performance-analyst
devops-engineer analytics-engineer community-manager
Unity Specialists:
unity-specialist unity-shader-specialist
unity-ui-specialist unity-dots-specialist
unity-addressables-specialist
Key principle: Directors never write code. Specialists never make vision decisions. Leads bridge the two. This separation prevents the AI from making unilateral decisions that cross domain boundaries.
Skills Overview
Studio Skills (72) — from Game Studios Template
| Category |
Skills |
Examples |
| Getting Started |
4 |
/start, /setup-engine, /adopt, /onboard |
| Design |
10 |
/brainstorm, /map-systems, /design-review, /quick-design |
| Architecture |
5 |
/create-architecture, /architecture-decision, /architecture-review |
| Sprint Management |
8 |
/create-epics, /create-stories, /sprint-plan, /sprint-status |
| Implementation |
6 |
/dev-story, /story-done, /code-review, /prototype |
| Team Orchestration |
8 |
/team-combat, /team-ui, /team-narrative, /team-audio, /team-polish |
| QA & Testing |
10 |
/qa-plan, /smoke-check, /test-setup, /regression-suite |
| Release |
6 |
/gate-check, /release-checklist, /launch-checklist, /day-one-patch |
| Utilities |
15 |
/bug-report, /tech-debt, /scope-check, /balance-check |
Unity API Skills (35) — from Unity Knowledge Plugin
| Category |
Skills |
| Core |
unity-foundations, unity-scripting, unity-lifecycle |
| Rendering |
unity-graphics, unity-lighting-vfx, unity-3d-math |
| Physics |
unity-physics, unity-physics-queries |
| UI |
unity-ui, unity-ui-patterns |
| Animation |
unity-animation, unity-cinemachine |
| Audio |
unity-audio |
| Input |
unity-input, unity-input-correctness |
| Systems |
unity-game-architecture, unity-state-machines, unity-data-driven |
| Networking |
unity-multiplayer |
| Advanced |
unity-ecs-dots, unity-async-patterns, unity-procedural-gen |
| Tools |
unity-editor-tools, unity-testing, unity-performance, unity-platforms |
| Design Translation |
unity-game-loop, unity-npc-behavior, unity-level-design, unity-save-system |
Middleware Skills (21) — from Middleware Plugin
| Skills |
unity-addressables, unity-behavior-designer, unity-cinemachine, unity-flowcanvas |
unity-gameplay-ability-system, unity-memorypack, unity-navmesh, unity-object-pooling |
unity-physics, unity-primetween, unity-profiling, unity-scriptable-objects |
unity-sentry, unity-state-machine, unity-test-framework, unity-ugui |
unity-unitask, unity-vcontainer, unity-wwise, unity-mobile-optimization |
unity-animation |
Workflow Commands (9) — from Unity AI Workflow
| Command |
Purpose |
/uw-cmd-setup-project |
Full project initialization wizard |
/uw-cmd-brainstorm |
Guided ideation and concept development |
/uw-cmd-plan |
Technical planning and architecture |
/uw-cmd-create |
Asset and system creation |
/uw-cmd-implement-feature |
Full feature loop: interrogate -> GDD -> TDD -> game feel -> commit |
/uw-cmd-test |
Test generation and execution |
/uw-cmd-debug |
Structured debugging workflow |
/uw-cmd-polish |
VFX, SFX, camera, tweens refinement |
/uw-cmd-review |
Code review with Unity-specific checks |
The Plugin System
Skills are loaded through Claude Code’s plugin architecture. This means you can mix and match:
Your Game Project
|
+-> game-studios-template/ (always loaded — core infrastructure)
| +-> .claude/agents/ (49 agents)
| +-> .claude/skills/ (72 skills)
| +-> .claude/hooks/ (12 hooks)
| +-> .claude/rules/ (11 rules)
|
+-> unity-knowledge-skills/ (plugin — deep Unity API knowledge)
| +-> skills/ (35 Unity skills, auto-discovered)
|
+-> unity-middleware-skills/ (plugin — production middleware)
| +-> skills/ (21 middleware skills, auto-discovered)
|
+-> unity-ai-workflow/ (optional — simplified commands)
+-> .claude/commands/ (9 workflow commands)
+-> .claude/skills/ (13 workflow skills)
Adding More Plugins
The system is extensible. Want roguelike-specific skills? Create a new plugin:
my-roguelike-skills/
+-- .claude-plugin/
| +-- plugin.json
+-- skills/
+-- dungeon-generation/
| +-- SKILL.md
+-- procedural-loot/
+-- SKILL.md
Drop it next to your project and load it with claude --plugin-dir ./my-roguelike-skills.
Director Gates (Quality Control)
The most powerful feature. Every major decision passes through quality gates:
How Gates Work
- You trigger a gate (e.g.,
/gate-check concept)
- Four directors review in parallel, each from their domain:
- Creative Director — Does this fit the game’s vision and pillars?
- Technical Director — Is the architecture sound? Risks documented?
- Producer — Is scope realistic for the timeline?
- Art Director — Is the visual identity established?
- Each returns:
READY, CONCERNS [list], or NOT READY [blockers]
- Strictest verdict wins — one
NOT READY blocks the whole phase
Gate Intensity Modes
| Mode |
Behavior |
Best For |
| full |
All gates run at every decision point |
Complex games, teams |
| lean |
Only phase gates at /gate-check |
Solo devs, medium projects |
| solo |
No director gates |
Game jams, rapid prototyping |
Set your mode in production/review-mode.txt.
Development Phases
The toolkit follows a structured development pipeline:
Concept -> Systems Design -> Architecture -> Pre-Production
| | | |
/start /map-systems /create-architecture /setup-engine
/brainstorm /design-review /architecture-decision /test-setup
/gate-check concept /gate-check pre-prod
|
v
Production -> Polish -> Release
| | |
/create-epics /team-polish /gate-check release
/create-stories /release-checklist
/dev-story /launch-checklist
/story-done /day-one-patch
/sprint-plan
/sprint-status
Each phase has a gate check. You can’t skip ahead without addressing concerns.
Usage Modes
Mode A: Full Studio (Maximum Structure)
Use the complete Game Studios Template with all agents, gates, and workflows. Best for serious projects where quality matters.
# Open your game workspace
cd MyGame && claude
# Start with guided onboarding
> /start
Mode B: Simplified Workflow (Guided Experience)
Use the Unity AI Workflow wrapper for a streamlined experience. Hides complexity behind 9 high-level commands. Best for solo devs and game jams.
# Copy unity-ai-workflow into your project
# Use /uw-cmd-* commands instead of the full skill set
> /uw-cmd-implement-feature "melee parry system"
Mode C: Hybrid (Recommended for Most)
Use the full studio for planning and oversight, and the workflow commands for implementation. This gives you both structure and speed.
Dev Modes (from Unity AI Workflow)
| Mode |
Behavior |
| guided (default) |
Collaborative. AI suggests; you confirm key decisions. |
| autonomous |
AI builds after onboarding Q&A. Minimal interruption. |
Set in docs/ProjectConfig.yaml -> ai_mode.
Project Structure
After setup, your game workspace looks like this:
MyGame/ <- Open THIS in Claude Code
+-- CLAUDE.md <- Auto-loaded AI instructions
+-- .claude/
| +-- agents/ <- 49 agent definitions
| +-- skills/ <- 72+ skills (slash commands)
| +-- hooks/ <- 12 automated hooks
| +-- rules/ <- 11 path-scoped coding standards
| +-- docs/ <- Coordination rules, standards, templates
+-- design/
| +-- gdd/ <- Game design documents (one per system)
| +-- narrative/ <- Story, lore, dialogue
| +-- levels/ <- Level design docs
| +-- balance/ <- Balance data and formulas
+-- src/ <- Game source code
| +-- core/ <- Core systems
| +-- gameplay/ <- Gameplay logic
| +-- ai/ <- AI/NPC behavior
| +-- networking/ <- Multiplayer code
| +-- ui/ <- UI code
+-- assets/ <- Art, audio, VFX, shaders
+-- tests/ <- Unit, integration, performance tests
+-- docs/ <- Technical docs, architecture, ADRs
+-- production/ <- Sprint plans, milestones, releases
+-- prototypes/ <- Throwaway prototypes (isolated from src/)
+-- MyGameUnity/ <- Unity project (Assets/, Packages/, etc.)
Important: Don’t open the Unity project directly in Claude Code. Open the parent workspace folder so Claude can read both design documents and Unity code simultaneously.
Slash Command Reference
Getting Started
| Command |
Description |
/start |
First-time onboarding — detects project state, guides you to the right workflow |
/setup-engine |
Configure Unity version, rendering pipeline, plugins |
/adopt |
Integrate existing project into the studio structure |
/onboard |
Generate onboarding doc for a new team member or contributor |
Design
| Command |
Description |
/brainstorm |
Guided ideation using MDA framework and player psychology |
/map-systems |
Decompose game concept into individual systems |
/design-review |
Review a GDD for completeness and consistency |
/quick-design |
Lightweight spec for small changes and tuning |
/review-all-gdds |
Cross-GDD consistency and game design theory review |
/balance-check |
Analyze balance data for outliers and broken progressions |
/consistency-check |
Scan all GDDs for cross-document inconsistencies |
Architecture
| Command |
Description |
/create-architecture |
Full architecture document from all GDDs |
/architecture-decision |
Create an ADR for a technical decision |
/architecture-review |
Validate architecture against all GDDs |
/create-control-manifest |
Produce actionable rules sheet for programmers |
Sprint & Stories
| Command |
Description |
/create-epics |
Translate GDDs + architecture into epics |
/create-stories |
Break an epic into implementable stories |
/sprint-plan |
Generate or update a sprint plan |
/sprint-status |
Quick progress snapshot with burndown |
/story-readiness |
Validate a story is implementation-ready |
/dev-story |
Implement a story end-to-end |
/story-done |
Completion review for a story |
/scope-check |
Check for scope creep |
Team Orchestration
| Command |
Description |
/team-combat |
Coordinate full combat feature development |
/team-ui |
Orchestrate UI team through full UX pipeline |
/team-narrative |
Coordinate story, lore, and narrative design |
/team-audio |
Full audio pipeline from direction to implementation |
/team-polish |
Optimize and polish a feature for release quality |
/team-qa |
Full QA testing cycle |
/team-level |
Complete area/level creation |
/team-release |
Execute a release from candidate to deployment |
/team-live-ops |
Plan seasons, events, and live content |
QA & Testing
| Command |
Description |
/qa-plan |
Generate QA test plan for a sprint or feature |
/test-setup |
Scaffold test framework and CI/CD pipeline |
/smoke-check |
Critical path smoke test before QA hand-off |
/regression-suite |
Map test coverage to critical paths |
/test-evidence-review |
Review test quality and assertion coverage |
/bug-report |
Create structured bug report |
/bug-triage |
Re-evaluate and prioritize open bugs |
Release
| Command |
Description |
/gate-check |
Phase transition gate (concept/pre-prod/prod/release) |
/release-checklist |
Pre-release validation checklist |
/launch-checklist |
Complete launch readiness validation |
/day-one-patch |
Emergency patch workflow for launch issues |
/hotfix |
Bypass normal process for emergency fixes |
Hooks & Automation
12 hooks fire automatically at lifecycle events:
| Hook |
When It Fires |
What It Does |
session-start |
Session opens |
Recover from crashes, read active.md |
detect-gaps |
Session opens |
Audit for missing artifacts |
session-stop |
Session ends |
Persist state for next session |
log-agent |
Subagent spawned |
Audit trail of who was called |
log-agent-stop |
Subagent ends |
Record output, cleanup |
validate-commit |
Before git commit |
Check files follow rules |
validate-push |
Before git push |
Final gate before remote push |
validate-assets |
After Write/Edit |
Check standards compliance |
validate-skill-change |
After skill edit |
Remind to run /skill-test |
pre-compact |
Before compaction |
Prep session state |
post-compact |
After compaction |
Remind to read active.md |
notify |
Notifications |
Windows toast / Discord alerts |
FAQ
Do I need a paid Claude account?
Yes. Claude Code requires either an Anthropic API key or a Claude Pro/Max subscription. The toolkit uses multiple model tiers (Haiku for simple tasks, Sonnet for implementation, Opus for reviews) to optimize cost.
Does this work with Unity 2022 / 2023?
The studio template and workflow are engine-agnostic. The Unity Knowledge Skills target Unity 6.3 LTS APIs, so some API references may differ on older versions. The core workflow (agents, skills, gates) works regardless of Unity version.
Can I use this with Godot or Unreal?
Yes! The Game Studios Template supports Godot 4 and Unreal Engine 5 with dedicated specialist agents for each. The Unity-specific plugins (knowledge skills, middleware skills, AI workflow) are Unity-only, but the studio structure works with any engine. Run /setup-engine to configure.
How much does it cost to run?
Costs depend on session length and which model tiers you use. A typical 2-hour session might use $2-10 in API credits. The tiered model system (Haiku for lookups, Sonnet for coding, Opus for reviews) keeps costs reasonable. Set gate intensity to “lean” or “solo” to reduce Opus usage.
Can I contribute new skills or agents?
Absolutely. The plugin system is designed for community extensions. Create a new plugin following the format in unity-knowledge-skills/.claude-plugin/, add your skills, and submit a PR.
What’s the difference between this and just using Claude Code?
Claude Code is a general-purpose AI assistant. This toolkit gives it the structure, knowledge, and workflows specific to professional game development. It’s the difference between having a smart generalist and having a coordinated team of 49 specialists who know game dev inside and out.
Credits
This project assembles and extends several outstanding open-source projects. See CREDITS.md for full attribution.
License
MIT License. Free to use, modify, and distribute. See LICENSE.
Packaged and documented by Ido Cohen.
评论