Game Development Studio

A Claude Code skill for game development projects, providing orchestration across game design, rendering, physics, audio, and deployment. Acts as a central routing skill that connects specialized game development sub-skills and provides core principles for building games.

When to Use This Skill

Choose Game Development Studio when:

• You're starting a new game development project
• You need guidance on game architecture and engine selection
• You want to implement game mechanics, physics, or rendering
• You're building a web-based game with Canvas, WebGL, or a game framework
• You need help with game loop design, state management, or input handling

Consider alternatives when:

• You need 3D rendering without game mechanics (use a 3D workspace skill)
• You want canvas drawing without game logic (use a canvas module skill)
• You need general animation without game context (use a frontend design skill)

Quick Start

Copy
# Install the skill
claude install game-development-studio

# Start a new game project
claude "Set up a 2D platformer using Phaser.js with TypeScript. Include player movement, gravity, and tile-based levels"

# Implement game mechanics
claude "Add a combat system to my RPG: turn-based battles with attack, defend, and special abilities"

# Build a web game
claude "Create a multiplayer snake game using Canvas and WebSocket for real-time sync"

Core Concepts

Game Architecture

Component	Responsibility	Implementation
Game Loop	Fixed timestep update + render cycle	requestAnimationFrame with delta time
State Manager	Game states (menu, playing, paused, game over)	Finite state machine
Entity System	Game objects with components	Entity-Component-System (ECS)
Input Handler	Keyboard, mouse, touch, gamepad	Event queue with action mapping
Physics Engine	Collision, gravity, movement	Custom or library (Matter.js, Rapier)
Renderer	Drawing game world to screen	Canvas 2D, WebGL, or framework
Audio Manager	Sound effects and music	Web Audio API or Howler.js
Asset Loader	Preload images, audio, data	Loading manager with progress

Game Frameworks

2D Frameworks:
├── Phaser.js → Full-featured, large community, good docs
├── PixiJS → High-performance rendering, lower-level
├── Kaboom.js → Simple, beginner-friendly, fun API
└── Excalibur.js → TypeScript-first, modern architecture

3D Frameworks:
├── Three.js → General 3D (not game-specific)
├── Babylon.js → Full game engine, built-in physics
├── PlayCanvas → Cloud-based game engine, WebGL 2
└── Godot (Web export) → Desktop engine with HTML5 export

Game Loop Pattern

Phase	Purpose	Typical Code
Input	Read and buffer player input	Poll keyboard/mouse state
Update	Run game logic at fixed timestep	Physics, AI, game rules
Render	Draw current game state	Clear canvas, draw entities
Audio	Play sounds based on events	Trigger SFX, manage music

Configuration

Parameter	Type	Default	Description
engine	string	"phaser"	Framework: phaser, pixi, kaboom, babylon, custom
game_type	string	"2d"	Type: 2d, 3d, isometric
genre	string	""	Genre for relevant patterns: platformer, rpg, puzzle, shooter
multiplayer	boolean	false	Include multiplayer architecture
target_platform	string	"web"	Platform: web, mobile, desktop

Best Practices

1. Separate update from render — Use a fixed timestep for game logic (60 updates/second) and render as fast as possible. This prevents game speed from depending on frame rate and makes physics consistent.

2. Use Entity-Component-System for anything beyond a prototype — ECS separates data (components) from behavior (systems). A "Player" is an entity with Position, Sprite, Health, and Input components. This makes it trivial to add new entity types.

3. Preload all assets before starting — Show a loading screen while images, audio, and level data load. Loading assets during gameplay causes stuttering. Use a loading manager that tracks progress.

4. Handle input through an abstraction layer — Don't check for specific keys in game logic. Map keys to actions ("jump", "attack") and check actions in game code. This makes input rebinding and controller support trivial.

5. Profile early and often — Games have strict performance budgets (16.7ms per frame at 60fps). Use browser performance tools to identify bottlenecks. Common culprits: too many draw calls, unoptimized collision detection, and garbage collection pauses.

Common Issues

Game runs at different speeds on different machines — You're tying game logic to frame rate. Use delta time (time since last frame) for movement: position.x += speed * deltaTime. Better yet, use a fixed timestep for physics.

Collision detection misses fast objects — Objects moving faster than their hitbox size per frame can pass through walls. Use continuous collision detection (sweep tests) for fast-moving objects, or limit maximum velocity.

Memory leaks causing slowdown — Game objects not being properly destroyed leave event listeners and references. Implement a proper entity lifecycle: create → update → destroy, with cleanup of all listeners and references on destroy.