settings-9da99b— hook

<p align="center"> <h1 align="center">Claude Unity Game Studio</h1> <p align="center"> Turn Claude Code into a complete Unity game development studio.<br/> 49 AI agents. 120+ skills. One coordinated team that builds games with you. </p> </p>

<p align="center"> <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a> <a href="game-studios-template/.claude/agents"><img src="https://img.shields.io/badge/agents-49-blueviolet" alt="49 Agents"></a> <a href="#skills-overview"><img src="https://img.shields.io/badge/skills-120+-green" alt="120+ Skills"></a> <a href="https://docs.anthropic.com/en/docs/claude-code"><img src="https://img.shields.io/badge/built%20for-Claude%20Code-f5f5f5?logo=anthropic" alt="Built for Claude Code"></a> </p>

Built With This Toolkit

<p align="center"> <img src="images/prototype.png" alt="Rodent Defense — a tower defense game built using Claude Unity Game Studio" width="720"> <br/> <em>Rodent Defense — a tower defense prototype built entirely using this toolkit and Claude Code.</em> </p>

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
• How It Works
• Prerequisites
• Quick Start (5 Minutes)
• Setup Options
• Your First Game: A Complete Walkthrough
• The Studio Hierarchy
• Skills Overview
• The Plugin System
• Director Gates (Quality Control)
• Development Phases
• Usage Modes
• Project Structure
• Slash Command Reference
• Hooks & Automation
• FAQ
• Credits
• License

What's Inside

This toolkit combines five specialized components into one cohesive system:

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:

1. 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.

1. 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.
2. Download and install Unity Hub (free — works on Windows, macOS, and Linux)
3. Create a free Unity account if you don't have one (Personal license is free)
4. In Unity Hub, click Installs > Install Editor and install Unity 6.3 LTS (recommended) or any Unity 6.x version
5. 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.

1. Git — For version control

   git --version  # Should be 2.x+

1. 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

Unity API Skills (35) — from Unity Knowledge Plugin

Middleware Skills (21) — from Middleware Plugin

Workflow Commands (9) — from Unity AI Workflow

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

1. You trigger a gate (e.g., /gate-check concept)
2. 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?

1. Each returns: READY, CONCERNS [list], or NOT READY [blockers]
2. Strictest verdict wins — one NOT READY blocks the whole phase

Gate Intensity Modes

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)

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

Design

Architecture

Sprint & Stories

Team Orchestration

QA & Testing

Release

Hooks & Automation

12 hooks fire automatically at lifecycle events:

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.