Back to Architecture & Design Patterns

Game Development Orchestrator

gamedevarchitecturegame-loopperformancepatterns
4.7 (93)28.1k📄 MIT🕒 2026-06-16Source ↗

Install this skill

npx skills add davila7/claude-code-templates

Works across Claude Code, Cursor, Codex, Copilot & Antigravity

What this skill does

  • Routes development tasks to specialized sub-skills
  • Provides standard templates for game loop implementation
  • Offers architectural guidance on pattern selection
  • Enforces input abstraction for multi-platform support
  • Supplies a performance budget for 60 FPS frame timing

When to use it

  • Starting a new game project from a blank codebase
  • Selecting appropriate data structures for game entity management
  • Determining which design pattern fits a specific gameplay mechanic
  • Optimizing rendering or physics performance within a strict frame budget

When not to use it

  • Performing general non-game software tasks
  • Handling backend API development unrelated to game state synchronization

How to invoke it

Example prompts that trigger this skill:

  • I need to set up a fixed-timestep game loop for my new project.
  • Which design pattern should I use for enemy AI in a 2D platformer?
  • Show me how to abstract input so I can support both keyboard and gamepad.
  • Help me optimize my physics simulation to maintain 60 FPS.
  • I am building a multiplayer game; what are the core architectural requirements?

Example workflow

  1. Define the project requirements and target platform via the orchestrator.
  2. Select the appropriate sub-skill for the platform and dimension (e.g., web/2d).
  3. Implement the core game loop using the provided fixed-timestep template.
  4. Apply the recommended design patterns for player state and entity management.
  5. Profile the game logic against the standard 16.67ms frame budget.
  6. Refine specific assets or systems using targeted sub-skills for audio or art.

Pitfalls & limitations

  • !Over-engineering simple projects by applying complex patterns like ECS prematurely.
  • !Ignoring the fixed-timestep requirement leading to physics jitter across different hardware.
  • !Attempting to optimize rendering before establishing a functional game loop.

FAQ

Do I need to use this for every game task?
It is most effective when establishing the initial project structure or when you encounter architectural bottlenecks.
Should I use ECS for everything?
No. Start with simpler patterns like state machines and only shift to ECS if your entity count creates significant performance spikes.
How does it help with cross-platform development?
The skill enforces input abstraction, ensuring your game logic interacts with action names instead of specific device keys.

How it compares

Generic prompts often lead to inconsistent code structures; this skill enforces established industry standards and architectural patterns tailored to specific game performance requirements.

Source & trust

28k stars📄 MIT🕒 Updated 2026-06-16🛡 runs-shell

From the source: “# Game Development > **Orchestrator skill** that provides core principles and routes to specialized sub-skills. --- ## When to Use This Skill You are working on a game development project. This skill teaches the PRINCIPLES of game development and directs you to the right sub-skill based on context. …”

View the full SKILL.md source

# Game Development

> **Orchestrator skill** that provides core principles and routes to specialized sub-skills.

---

## When to Use This Skill

You are working on a game development project. This skill teaches the PRINCIPLES of game development and directs you to the right sub-skill based on context.

---

## Sub-Skill Routing

### Platform Selection

| If the game targets... | Use Sub-Skill |
|------------------------|---------------|
| Web browsers (HTML5, WebGL) | `game-development/web-games` |
| Mobile (iOS, Android) | `game-development/mobile-games` |
| PC (Steam, Desktop) | `game-development/pc-games` |
| VR/AR headsets | `game-development/vr-ar` |

### Dimension Selection

| If the game is... | Use Sub-Skill |
|-------------------|---------------|
| 2D (sprites, tilemaps) | `game-development/2d-games` |
| 3D (meshes, shaders) | `game-development/3d-games` |

### Specialty Areas

| If you need... | Use Sub-Skill |
|----------------|---------------|
| GDD, balancing, player psychology | `game-development/game-design` |
| Multiplayer, networking | `game-development/multiplayer` |
| Visual style, asset pipeline, animation | `game-development/game-art` |
| Sound design, music, adaptive audio | `game-development/game-audio` |

---

## Core Principles (All Platforms)

### 1. The Game Loop

Every game, regardless of platform, follows this pattern:

```
INPUT  → Read player actions
UPDATE → Process game logic (fixed timestep)
RENDER → Draw the frame (interpolated)
```

**Fixed Timestep Rule:**
- Physics/logic: Fixed rate (e.g., 50Hz)
- Rendering: As fast as possible
- Interpolate between states for smooth visuals

---

### 2. Pattern Selection Matrix

| Pattern | Use When | Example |
|---------|----------|---------|
| **State Machine** | 3-5 discrete states | Player: Idle→Walk→Jump |
| **Object Pooling** | Frequent spawn/destroy | Bullets, particles |
| **Observer/Events** | Cross-system communication | Health→UI updates |
| **ECS** | Thousands of similar entities | RTS units, particles |
| **Command** | Undo, replay, networking | Input recording |
| **Behavior Tree** | Complex AI decisions | Enemy AI |

**Decision Rule:** Start with State Machine. Add ECS only when performance demands.

---

### 3. Input Abstraction

Abstract input into ACTIONS, not raw keys:

```
"jump"  → Space, Gamepad A, Touch tap
"move"  → WASD, Left stick, Virtual joystick
```

**Why:** Enables multi-platform, rebindable controls.

---

### 4. Performance Budget (60 FPS = 16.67ms)

| System | Budget |
|--------|--------|
| Input | 1ms |
| Physics | 3ms |
| AI | 2ms |
| Game Logic | 4ms |
| Rendering | 5ms |
| Buffer | 1.67ms |

**Optimization Priority:**
1. Algorithm (O(n²) → O(n log n))
2. Batching (reduce draw calls)
3. Pooling (avoid GC spikes)
4. LOD (detail by distance)
5. Culling (skip invisible)

---

### 5. AI Selection by Complexity

| AI Type | Complexity | Use When |
|---------|------------|----------|
| **FSM** | Simple | 3-5 states, predictable behavior |
| **Behavior Tree** | Medium | Modular, designer-friendly |
| **GOAP** | High | Emergent, planning-based |
| **Utility AI** | High | Scoring-based decisions |

---

### 6. Collision Strategy

| Type | Best For |
|------|----------|
| **AABB** | Rectangles, fast checks |
| **Circle** | Round objects, cheap |
| **Spatial Hash** | Many similar-sized objects |
| **Quadtree** | Large worlds, varying sizes |

---

## Anti-Patterns (Universal)

| Don't | Do |
|-------|-----|
| Update everything every frame | Use events, dirty flags |
| Create objects in hot loops | Object pooling |
| Cache nothing | Cache references |
| Optimize without profiling | Profile first |
| Mix input with logic | Abstract input layer |

---

## Routing Examples

### Example 1: "I want to make a browser-based 2D platformer"
→ Start with `game-development/web-games` for framework selection
→ Then `game-development/2d-games` for sprite/tilemap patterns
→ Reference `game-development/game-design` for level design

### Example 2: "Mobile puzzle game for iOS and Android"
→ Start with `game-development/mobile-games` for touch input and stores
→ Use `game-development/game-design` for puzzle balancing

### Example 3: "Multiplayer VR shooter"
→ `game-development/vr-ar` for comfort and immersion
→ `game-development/3d-games` for rendering
→ `game-development/multiplayer` for networking

---

> **Remember:** Great games come from iteration, not perfection. Prototype fast, then polish.

Quoted from davila7/claude-code-templates for reference — see the original for the authoritative, latest version.

📄 Full skill instructions — original source: davila7/claude-code-templates
This skill acts as a central command hub for game development tasks. It standardizes the architectural approach by organizing project requirements into specific technical domains, such as 2D sprite rendering, 3D mesh integration, multiplayer networking, and platform-specific deployment. By centralizing core principles like the fixed-timestep loop, input abstraction, and performance budgeting, it minimizes common development errors. It identifies the optimal design pattern for your current task—ranging from state machines for simple AI to Entity-Component Systems for high-density simulation—ensuring that your project remains performant and maintainable. Instead of starting from scratch, developers interact with this skill to receive architectural guidance, allowing them to focus on unique gameplay mechanics while the orchestrator enforces standard conventions across art, audio, and physics systems for desktop, mobile, web, and VR targets.

How to Use This Skill Unit

Option A: Project-Specific (Recommended)

  1. Click "Download" above
  2. In your project, create the directory: .agent/skills/game-development/
  3. Save the file as SKILL.md
  4. The agent will automatically discover the skill based on its description.

Option B: Global Installation (All Agents)

Save the file to these locations to make it available across all projects:

  • Claude Code: ~/.claude/skills/davila7/claude-code-templates/game-development/SKILL.md
  • Cursor: ~/.cursor/skills/davila7/claude-code-templates/game-development/SKILL.md
  • Antigravity: ~/.gemini/antigravity/skills/davila7/claude-code-templates/game-development/SKILL.md

🚀 Install with CLI:
npx skills add davila7/claude-code-templates

Read the Master Guide: Mastering Agent Skills

Recommended Rules

View more rules

Recommended Workflows

View more workflows

Recommended MCP Servers

View more MCP servers

Take It Further

Maximize your productivity with these powerful resources

📋

Define Your Standards

Set up coding standards to ensure this workflow produces consistent, high-quality results.

Browse Rules Library
📖

Master Workflows

Learn how to create custom workflows, use Turbo Mode, and build your automation library.

Complete Guide

How to use this Skill in Claude Code & Cursor

For Claude Code (CLI)

To use this skill in Claude Code, copy the rule content into your project's custom instructions or follow our Add-Skill CLI guide. This ensures Claude follows your standards during every code generation.

For Cursor & Windsurf

For Cursor or Windsurf, individual skills are best used in the "Rules for AI" section. This specific unit helps the agent avoid architecture & design patterns issues, leading to cleaner, more efficient code.

Why the skill format matters: the standardized Agent Skills format lets your AI agent load detailed instructions only when they are relevant, keeping your prompt clean while improving results.

Source & attribution

This skill is categorized under Architecture & Design Patterns and is published by davila7, maintained in davila7/claude-code-templates.

← Browse All Agent Skills
Sponsored AI assistant. Recommendations may be paid.