Claude Code Game Studios

Claude Code Game Studios

Skill by ara.so — Claude Code Skills collection.

What It Does

Claude Code Game Studios transforms a single Claude Code session into a complete game development studio with:

• 49 specialized agents organized in a 3-tier studio hierarchy (Directors → Department Leads → Specialists)
• 73 slash commands covering brainstorming, design, architecture, implementation, QA, and release
• 12 automated hooks for validation, session tracking, and quality gates
• 11 path-scoped rules enforcing coding standards per domain (gameplay, engine, AI, UI, network)
• 41 document templates for GDDs, ADRs, sprint plans, accessibility specs, and more

Instead of one general-purpose AI assistant, you get a coordinated team with clear responsibilities, escalation paths, and quality gates — while you stay in full control of every decision.

Installation

Prerequisites

# Required
npm install -g @anthropic-ai/claude-code

# Optional (for hook validation)
brew install jq  # or apt-get install jq
python3 --version  # should be 3.x

Setup New Project

# Clone as template
git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game-project
cd my-game-project

# Start Claude Code
claude

# Run initial setup
/start

Add to Existing Project

cd your-existing-game

# Clone template files
git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git .ccgs-temp
cp -r .ccgs-temp/.claude .
cp .ccgs-temp/CLAUDE.md .
rm -rf .ccgs-temp

# Detect existing project structure
claude
/adopt

Studio Hierarchy

Agents are organized in three tiers matching real studio structure:

Tier 1 — Directors (Opus Model)

creative-director:    # Guards game vision, resolves design conflicts
technical-director:   # Owns architecture decisions, performance targets
producer:            # Coordinates cross-department changes, manages scope

Tier 2 — Department Leads (Sonnet Model)

game-designer:        # Owns systems design, balance
lead-programmer:      # Code architecture, tech stack decisions
art-director:         # Visual style, asset pipeline
audio-director:       # Audio design, implementation strategy
narrative-director:   # Story structure, dialogue systems
qa-lead:             # Test strategy, quality gates
release-manager:     # Build pipeline, deployment
localization-lead:   # i18n strategy, text management

Tier 3 — Specialists (Sonnet/Haiku Model)

# Programming
gameplay-programmer, engine-programmer, ai-programmer,
network-programmer, tools-programmer, ui-programmer

# Design
systems-designer, level-designer, economy-designer,
live-ops-designer, ux-designer

# Art & Audio
technical-artist, sound-designer

# Production & QA
qa-tester, accessibility-specialist, performance-analyst,
devops-engineer, analytics-engineer, security-engineer,
community-manager

# Content
writer, world-builder, prototyper

Engine Specialists

# Godot 4
godot-specialist:
  - gdscript-programmer
  - shader-programmer
  - gdextension-programmer

# Unity
unity-specialist:
  - dots-ecs-programmer
  - shader-vfx-programmer
  - addressables-programmer
  - uitoolkit-programmer

# Unreal Engine 5
unreal-specialist:
  - gas-programmer
  - blueprint-programmer
  - replication-programmer
  - umg-commonui-programmer

Core Workflow Commands

Phase 1: Onboarding & Setup

/start                    # Guided onboarding (detects project stage)
/help                     # Show all available commands
/project-stage-detect     # Analyze existing project
/setup-engine godot 4.6   # Configure engine-specific settings
/adopt                    # Import existing project structure

Phase 2: Game Design

/brainstorm              # Generate game concepts
/map-systems            # Map core game systems and interactions
/design-system combat    # Create detailed system GDD
/quick-design           # Lightweight design for small features
/review-all-gdds        # Audit all design documents
/propagate-design-change # Update docs after design pivot

Example: Design a combat system

# In Claude Code session
/design-system combat

# Agent (systems-designer) asks:
# 1. What's the core player fantasy?
# 2. Turn-based or real-time?
# 3. Complexity target (arcade/sim/hybrid)?
# 4. Key reference games?

# After answers, creates:
# design/systems/combat.md (GDD)
# design/systems/combat-flowchart.mermaid
# src/systems/combat/.design-manifest.json

Phase 3: Architecture

/create-architecture          # Design technical architecture
/architecture-decision        # Record ADR for tech choice
/architecture-review         # Review existing architecture
/create-control-manifest     # Map input/control schemes

Example: Architecture Decision Record

/architecture-decision

# Creates docs/adr/NNNN-network-architecture.md
# Prompts for:
# - Context: Why this decision is needed
# - Options considered (with pros/cons)
# - Decision made
# - Consequences

Phase 4: Implementation

/create-epics               # Break project into epics
/create-stories combat      # Generate user stories for epic
/dev-story GAME-123        # Implement specific story
/story-done GAME-123       # Mark story complete (runs QA)
/sprint-plan               # Plan upcoming sprint
/sprint-status            # Show sprint progress

Example: Implement a story

/dev-story GAME-45

# Reads production/stories/GAME-45.md
# Spawns appropriate agents (e.g., gameplay-programmer + systems-designer)
# Shows implementation plan for approval
# Writes code in src/
# Updates story status
# Runs story-level tests

Phase 5: Quality & Review

/code-review src/combat/    # Review code quality
/design-review combat       # Review design doc completeness
/balance-check             # Analyze game balance
/perf-profile             # Performance analysis
/tech-debt                # Identify technical debt
/security-audit           # Security review
/consistency-check        # Cross-system consistency

Phase 6: Testing

/qa-plan                  # Create test strategy
/smoke-check             # Quick sanity tests
/soak-test               # Long-running stability test
/regression-suite        # Run full regression
/test-setup              # Configure test environment
/test-helpers            # Generate test utilities
/test-evidence-review    # Validate test coverage

Example: QA workflow

# After implementing GAME-45
/story-done GAME-45

# Automatically:
# 1. Runs /smoke-check on affected systems
# 2. Checks test coverage (warns if <80%)
# 3. Updates production/stories/GAME-45.md status
# 4. Moves to "Ready for Review"

Phase 7: Release

/release-checklist        # Pre-release validation
/launch-checklist        # Launch day tasks
/changelog               # Generate changelog
/patch-notes             # Write player-facing notes
/hotfix                  # Emergency fix workflow
/day-one-patch           # Plan day-one update

Team Coordination Commands

For features requiring multiple departments:

/team-combat             # Combat system (design + gameplay + VFX + audio)
/team-narrative          # Story content (narrative + world-builder + writer)
/team-ui                # UI feature (ux-designer + ui-programmer + accessibility)
/team-release           # Release prep (all leads)
/team-polish            # Pre-launch polish (art + audio + QA)
/team-level             # Level creation (level-designer + technical-artist)
/team-live-ops          # Live service (live-ops-designer + analytics)
/team-qa                # Quality push (qa-lead + all testers)

Example: Multi-agent feature

/team-combat

# Spawns coordination team:
# - systems-designer (mechanics)
# - gameplay-programmer (implementation)
# - technical-artist (VFX)
# - sound-designer (audio)
# - qa-tester (combat-specific tests)

# Creates shared context document
# Coordinates work phases
# Ensures integration testing

Project Structure

my-game/
├── CLAUDE.md                    # Master config (agent registry)
├── .claude/
│   ├── settings.json           # Hooks, permissions, safety rules
│   ├── agents/                 # 49 agent definitions
│   │   ├── creative-director.md
│   │   ├── gameplay-programmer.md
│   │   └── ...
│   ├── skills/                 # 73 slash commands
│   │   ├── start/
│   │   │   ├── SKILL.md
│   │   │   └── metadata.json
│   │   └── ...
│   ├── hooks/                  # 12 automation hooks
│   │   ├── validate-commit.sh
│   │   ├── session-start.sh
│   │   └── ...
│   ├── rules/                  # 11 coding standards
│   │   ├── gameplay-code.md
│   │   ├── engine-code.md
│   │   └── ...
│   └── docs/
│       ├── workflow-catalog.yaml
│       └── templates/          # 41 doc templates
├── src/                        # Game source code
├── assets/                     # Art, audio, data
├── design/                     # GDDs, narrative docs
├── docs/                       # ADRs, technical docs
├── tests/                      # Test suites
├── production/                 # Sprint plans, stories
└── prototypes/                 # Isolated experiments

Configuration

Engine Selection

Edit CLAUDE.md to activate your engine's specialists:

## Active Specialists

### Godot 4
- godot-specialist (tier-2-lead)
  - gdscript-programmer
  - shader-programmer
  - gdextension-programmer

<!-- Disable unused engines:
### Unity
- unity-specialist (tier-2-lead)
  ...
-->

Hook Configuration

Edit .claude/settings.json:

{
  "hooks": {
    "session.open": [".claude/hooks/session-start.sh"],
    "session.close": [".claude/hooks/session-stop.sh"],
    "preToolUse": {
      "Bash": [
        ".claude/hooks/validate-commit.sh",
        ".claude/hooks/validate-push.sh"
      ]
    },
    "postToolUse": {
      "WriteFile": [".claude/hooks/validate-assets.sh"],
      "EditFile": [".claude/hooks/validate-skill-change.sh"]
    }
  }
}

Permission Rules

{
  "permissions": {
    "allowed_commands": [
      "git status",
      "git log",
      "pytest tests/",
      "npm test"
    ],
    "blocked_paths": [
      ".env",
      "secrets/",
      "production/credentials/"
    ]
  }
}

Common Patterns

Start New Game from Scratch

/start
# Choose: "No idea, just exploring"
/brainstorm
# Discuss concepts, pick one
/map-systems
# Define core systems
/design-system [system-name]
# Detail each system
/create-architecture
# Plan tech stack
/setup-engine godot 4.6
# Configure engine
/create-epics
# Break into epics
/create-stories [epic-name]
# Generate user stories
/sprint-plan
# Plan first sprint

Import Existing Project

/adopt
# Scans src/, assets/, design/
# Detects gaps (missing GDDs, ADRs)
# Suggests next steps

/reverse-document src/combat/
# Generates design doc from code

/architecture-review
# Analyzes current structure
# Recommends improvements

Daily Development Loop

/sprint-status
# See current sprint progress

/dev-story GAME-67
# Implement next story

/story-done GAME-67
# QA + mark complete

/code-review src/inventory/
# Periodic quality check

Pre-Release Workflow

/gate-check alpha
# Validate alpha criteria

/regression-suite
# Full test pass

/perf-profile
# Performance validation

/release-checklist alpha
# Final checks

/changelog
# Generate changelog

/patch-notes
# Write player-facing notes

Real Code Examples

Godot 4 Combat System (GDScript)

# Generated by /dev-story GAME-12 (gameplay-programmer)
# Design: design/systems/combat.md
# ADR: docs/adr/0003-combat-state-machine.md

class_name CombatController
extends Node

## Combat state machine following design/systems/combat.md
## Manages turn order, damage resolution, status effects

signal turn_started(combatant: Combatant)
signal turn_ended(combatant: Combatant)
signal combat_ended(victor: Team)

enum CombatState { SETUP, PLAYER_TURN, ENEMY_TURN, RESOLUTION, ENDED }

@export var turn_time_limit: float = 30.0  # From combat.md: 30s turn timer
@export var damage_formula: DamageFormula  # Injected, see ADR-0003

var _state: CombatState = CombatState.SETUP
var _turn_queue: Array[Combatant] = []
var _active_combatant: Combatant

func _ready() -> void:
    assert(damage_formula != null, "DamageFormula required")
    _initialize_turn_queue()

func execute_action(action: CombatAction) -> void:
    # Validates action legality (design constraint: one action per turn)
    assert(action.actor == _active_combatant, "Not active combatant's turn")
    
    var result := damage_formula.calculate(action)
    _apply_damage(result)
    _check_status_effects()
    _end_turn()

Unity DOTS Combat (C#)

// Generated by /dev-story GAME-23 (dots-ecs-programmer)
// Design: design/systems/combat.md
// ADR: docs/adr/0005-dots-combat-architecture.md

using Unity.Entities;
using Unity.Mathematics;
using Unity.Collections;

[UpdateInGroup(typeof(SimulationSystemGroup))]
public partial struct CombatResolutionSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        // Process all pending combat actions (batched per design/systems/combat.md)
        var ecb = new EntityCommandBuffer(Allocator.TempJob);
        
        foreach (var (action, entity) in 
            SystemAPI.Query<RefRO<CombatAction>>()
                .WithEntityAccess())
        {
            // Calculate damage using formula from combat.md
            var damage = CalculateDamage(
                action.ValueRO.AttackerPower,
                action.ValueRO.DefenderArmor,
                action.ValueRO.CriticalChance
            );
            
            // Apply damage to target (buffered to avoid structural changes)
            ecb.SetComponent(action.ValueRO.Target, new Health 
            { 
                Current = math.max(0, GetHealth(action.ValueRO.Target) - damage)
            });
            
            // Remove processed action
            ecb.DestroyEntity(entity);
        }
        
        ecb.Playback(state.EntityManager);
        ecb.Dispose();
    }
    
    private float CalculateDamage(float power, float armor, float critChance)
    {
        // Formula from design/systems/combat.md section 3.2
        var baseDamage = power * (100f / (100f + armor));
        var isCrit = UnityEngine.Random.value < critChance;
        return baseDamage * (isCrit ? 1.5f : 1.0f);  // 150% crit multiplier per design
    }
}

Unreal Engine 5 GAS Ability (C++)

// Generated by /dev-story GAME-34 (gas-programmer)
// Design: design/systems/combat.md
// ADR: docs/adr/0007-gas-ability-system.md

#pragma once

#include "CoreMinimal.h"
#include "Abilities/GameplayAbility.h"
#include "MeleeAttackAbility.generated.h"

/**
 * Melee attack ability implementing design/systems/combat.md
 * Uses GAS for damage calculation, status effects, cooldowns
 */
UCLASS()
class MYGAME_API UMeleeAttackAbility : public UGameplayAbility
{
    GENERATED_BODY()

public:
    UMeleeAttackAbility();

    virtual void ActivateAbility(
        const FGameplayAbilitySpecHandle Handle,
        const FGameplayAbilityActorInfo* ActorInfo,
        const FGameplayAbilityActivationInfo ActivationInfo,
        const FGameplayEventData* TriggerEventData
    ) override;

protected:
    /** Base damage (modified by GE_DamageCalculation) */
    UPROPERTY(EditDefaultsOnly, Category = "Combat")
    float BaseDamage = 10.0f;

    /** Attack range in cm (from combat.md: 200cm melee range) */
    UPROPERTY(EditDefaultsOnly, Category = "Combat")
    float AttackRange = 200.0f;

    /** Damage calculation gameplay effect */
    UPROPERTY(EditDefaultsOnly, Category = "Combat")
    TSubclassOf<UGameplayEffect> DamageEffectClass;

private:
    void ApplyDamageToTarget(AActor* Target);
    bool IsInAttackRange(AActor* Target) const;
};

Troubleshooting

Hooks Not Running

# Check hook permissions
ls -l .claude/hooks/
# Should be -rwxr-xr-x (executable)

# Make executable if needed
chmod +x .claude/hooks/*.sh

# Test individual hook
.claude/hooks/validate-commit.sh

Agent Not Found

# Verify agent exists
ls .claude/agents/ | grep gameplay-programmer

# Check CLAUDE.md registry
grep "gameplay-programmer" CLAUDE.md

# If missing, agent was removed — restore from template or create custom

Skill Fails to Load

# Validate skill metadata
cat .claude/skills/dev-story/metadata.json | jq .

# Check for syntax errors
python3 -m json.tool .claude/skills/dev-story/metadata.json

# Test skill in isolation
/skill-test dev-story

# Fix issues, then re-test
/skill-improve dev-story

Validation Errors on Commit

# Hook found issues — read output
git commit -m "Add combat system"
# ❌ Validation failed: Hardcoded magic number in src/combat/damage.gd:42

# Fix the issue
# Replace: var damage = power * 1.5
# With: const CRIT_MULTIPLIER = 1.5; var damage = power * CRIT_MULTIPLIER

# Commit again
git commit -m "Add combat system"
# ✅ Validation passed

Context Limit Warnings

# Project grew too large for context window
# Compact session history (preserves active.md)
claude compact

# Or work in focused mode (single epic)
/sprint-plan
# Select subset of stories to minimize loaded context

Engine Specialist Not Available

# Check CLAUDE.md for active specialists
# If godot-specialist is commented out:

## Active Specialists
<!-- 
### Godot 4
- godot-specialist
-->

# Uncomment to activate:
### Godot 4
- godot-specialist (tier-2-lead)
  - gdscript-programmer
  - shader-programmer

Support & Community

• Documentation: Full workflow catalog
• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Support the project: Buy Me a Coffee or GitHub Sponsors

License

MIT License — see LICENSE file for details.