GA

game-development

A high-level assistant that manages game development tasks and directs the user to specialized sub-skills based on project needs.

Install

mkdir -p .claude/skills/game-development && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/790" && unzip -o skill.zip -d .claude/skills/game-development && rm skill.zip

Installs to .claude/skills/game-development

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Game development orchestrator. Routes to platform-specific skills based on project needs.
89 charsno explicit “when” trigger
Intermediate

Key capabilities

  • →Route projects to platform-specific sub-skills
  • →Apply fixed timestep game loop logic
  • →Implement design patterns like state machines and object pooling
  • →Abstract input into actions for multi-platform support
  • →Optimize performance based on a 16.67ms frame budget
  • →Select AI strategies ranging from FSM to utility-based systems

How it works

The skill acts as an orchestrator that maps project needs to specific sub-skills based on platform, dimension, and specialty requirements. It provides universal core principles like the fixed timestep game loop and performance budgeting.

Inputs & outputs

You give it
Project requirements and target platform
You get back
Routing to specialized sub-skills and architectural principles

When to use game-development

  • →Initialize a new game project architecture
  • →Determine platform-specific development needs
  • →Apply core game loop logic to a project
  • →Understand asset pipeline requirements

About this skill

Game Development

Core principles that hold in every engine, plus a map of the reference guides in references/. Read this file first, then open only the references the task needs.

Workflow

  1. Find out what already exists. Before suggesting an engine or architecture, look for project files:

    File in the projectEngine / stack
    project.godot, *.gd, *.tscnGodot
    ProjectSettings/ProjectVersion.txt, Assets/, *.unityUnity
    *.uproject, Source/, Config/DefaultEngine.iniUnreal
    package.json with phaser, pixi.js, three, @babylonjs/coreWeb framework
    <canvas> + requestAnimationFrame with no frameworkRaw Canvas/WebGL

    Match the engine's conventions and version already in use. Never migrate engines or frameworks unless asked.

  2. Read the matching references (table below). One platform guide plus one dimension guide covers most tasks.

  3. Get the core loop playable first. Placeholder shapes and sounds are fine. Fun is found by playing, not by planning: polish, menus and content come after the 30-second loop feels good.

  4. Keep game logic separate from rendering and input, so it can be tested and reasoned about without a frame running (see Core principles).

  5. Measure before optimizing. Use the engine profiler or the browser Performance panel, find the slowest system, fix that, measure again.

  6. Verify by running it. Launch the game (or its tests) after each change; a game that compiles can still be unplayable. For browser games, open the page and check the console for errors.

Reference guides

Each file is self-contained. Load it with the Read tool when the task touches its topic.

When the task involves...Read
Browser games: framework choice, WebGPU/WebGL, asset loading, audio unlock, PWAreferences/web-games.md
iOS/Android: touch input, battery, thermals, store rulesreferences/mobile-games.md
PC/console: engine choice (Unity, Godot, Unreal), Steam, controllers, certificationreferences/pc-games.md
VR/AR: comfort, frame rate, interaction, world scalereferences/vr-ar.md
2D: sprites, tilemaps, 2D physics, cameras, platformer feelreferences/2d-games.md
3D: rendering, shaders, lighting, LOD, 3D camerasreferences/3d-games.md
Design: core loop, GDD, difficulty, progression, rewardsreferences/game-design.md
Online play: architecture, netcode, lag compensation, anti-cheatreferences/multiplayer.md
Visual style, asset pipeline, animation, namingreferences/game-art.md
Sound design, music systems, mixing, spatial audioreferences/game-audio.md

Examples:

  • "Browser 2D platformer": web-games.md, then 2d-games.md; game-design.md for level pacing.
  • "Mobile puzzle game": mobile-games.md, then game-design.md for difficulty curves.
  • "Multiplayer VR shooter": vr-ar.md, 3d-games.md, multiplayer.md.

Core principles

1. Game loop with a fixed timestep

Run simulation (physics, gameplay) at a fixed rate and render as often as the display allows, interpolating between the last two simulation states. A variable dt in physics makes jumps, collisions and replays depend on frame rate.

const STEP = 1 / 60;          // simulation rate (seconds)
const MAX_FRAME = 0.25;       // clamp to avoid the "spiral of death" after a stall
let acc = 0, last = performance.now() / 1000;

function frame(nowMs) {
  const now = nowMs / 1000;
  acc += Math.min(now - last, MAX_FRAME);
  last = now;
  while (acc >= STEP) {
    applyInput();             // consume actions latched by input events, so a frame with zero ticks loses nothing
    update(STEP);             // deterministic: same input, same result
    acc -= STEP;
  }
  render(acc / STEP);         // alpha in [0,1): blend previous and current state
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

Engines already provide this split; use theirs instead of writing a second loop: Godot _physics_process vs _process, Unity FixedUpdate vs Update, Phaser Arcade physics (fixedStep: true by default, rate set by physics.arcade.fps). Unreal's Tick is variable-rate; enable physics substepping in Project Settings and keep DeltaSeconds out of deterministic logic.

2. Input as actions, not keys

Map device input to named actions and read only actions in gameplay code:

"jump" → Space, Gamepad South, tap
"move" → WASD / arrows, left stick, virtual joystick

This gives rebinding, gamepad and touch support for free, and makes input recordable for replays and tests. Use the engine's system where it exists (Godot InputMap, Unity Input System actions, Unreal Enhanced Input). Buffer short inputs (about 100 ms) so a press just before landing still jumps.

3. Pick the simplest pattern that fits

PatternUse whenExample
State machineA handful of exclusive statesPlayer: idle, run, jump, fall
Object poolFrequent spawn/destroyBullets, particles, damage numbers
Events / signalsOne system reacts to anotherHealth change updates the HUD
CommandUndo, replay, networkingRecorded inputs
Behavior treeModular AI built by designersEnemy patrol, chase, attack
ECS / data-orientedThousands of similar entitiesRTS units, bullet hell

Start with plain objects and a state machine; move to ECS only when a profile shows per-entity overhead is the bottleneck.

4. Frame budget

TargetBudget per frame
30 FPS33.3 ms
60 FPS16.7 ms
72 FPS (Quest)13.9 ms
90 FPS (VR)11.1 ms
120 FPS8.3 ms

CPU (logic, physics, AI, draw submission) and GPU (rendering) work in parallel, so each must fit the budget on its own; the slower one sets the frame rate. Leave headroom (about 20%) for spikes and slower devices. Check which side is the bottleneck before optimizing: lowering resolution helps only if the GPU is the limit.

Optimization order, cheapest win first:

  1. Better algorithm or data structure (O(n²) checks become a spatial hash)
  2. Do less: culling, update off-screen entities less often, dirty flags
  3. Fewer draw calls: atlases, batching, instancing
  4. No allocations in the hot loop: pooling, reused buffers (avoids GC spikes)
  5. LOD for meshes, effects and AI tick rate

5. AI by complexity

ApproachUse when
FSMFew states, predictable behaviour
Behavior treeMany reusable behaviours, designer-tunable
Utility AIChoosing among many options by score
GOAP / planningEmergent multi-step goals (costly; rarely needed)

Run AI at a lower rate than the frame (5-10 Hz is often enough) and spread agents across frames.

6. Collision

TechniqueBest for
AABB / circleMost 2D games, cheap broad checks
CapsuleCharacters (slides along walls and steps)
Spatial hash / gridMany objects of similar size
Quadtree / BVHLarge worlds with varied sizes

Use simple collision shapes under detailed visuals. Fast objects need swept (continuous) collision or a raycast between positions, or they tunnel through thin walls.

7. Game feel

Small touches decide whether controls feel responsive: coyote time (jump allowed ~100 ms after leaving a ledge), jump buffering, variable jump height, hit-stop of a few frames on impact, short screen shake that decays, and an audio and visual response to every player action within the same frame.

Anti-patterns

Don'tDo
Physics with variable dtFixed timestep, interpolate rendering
Read raw keys in gameplay codeAction map
Allocate objects every framePools and reused buffers
Poll every system every frameEvents, dirty flags, lower tick rates
Optimize by guessProfile, fix the top item, profile again
Build menus and content before the loop is funPlayable prototype first
Trust the client in online gamesServer-authoritative state (see multiplayer.md)
Switch engines mid-project to fix one problemSolve it in the current engine

When not to use it

  • →When the project does not require game development principles
  • →When seeking general software architecture advice outside of game loops

Limitations

  • →Requires manual routing to sub-skills for specific implementation details
  • →Does not provide direct code generation for game engines

How it compares

Unlike a general development guide, this skill provides a structured routing matrix to specialized game-domain sub-skills and enforces game-specific architectural constraints like fixed timesteps.

Compared to similar skills

game-development side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
game-development (this skill)7010moNo flagsIntermediate
software-architecture33310moNo flagsIntermediate
codex325moReviewAdvanced
senior-fullstack3511moReviewIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

software-architecture

davila7

Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.

333868

planning-with-files

davila7

Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks, research projects, or any task requiring >5 tool calls.

233106

telegram-bot-builder

davila7

Expert in building Telegram bots that solve real problems - from simple automation to complex AI-powered bots. Covers bot architecture, the Telegram Bot API, user experience, monetization strategies, and scaling bots to thousands of users. Use when: telegram bot, bot api, telegram automation, chat bot telegram, tg bot.

106130

scroll-experience

davila7

Expert in building immersive scroll-driven experiences - parallax storytelling, scroll animations, interactive narratives, and cinematic web experiences. Like NY Times interactives, Apple product pages, and award-winning web experiences. Makes websites feel like experiences, not just pages. Use when: scroll animation, parallax, scroll storytelling, interactive story, cinematic website.

101142

humanizer

davila7

Remove signs of AI-generated writing from text. Use when editing or reviewing text to make it sound more natural and human-written. Based on Wikipedia's comprehensive "Signs of AI writing" guide. Detects and fixes patterns including: inflated symbolism, promotional language, superficial -ing analyses, vague attributions, em dash overuse, rule of three, AI vocabulary words, negative parallelisms, and excessive conjunctive phrases. Credits: Original skill by @blader - https://github.com/blader/humanizer

90175

2d-games

davila7

2D game development principles. Sprites, tilemaps, physics, camera.

66189

You might also like

software-architecture

davila7

Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.

333868

codex

Lucklyric

Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.

32238

senior-fullstack

davila7

Comprehensive fullstack development skill for building complete web applications with React, Next.js, Node.js, GraphQL, and PostgreSQL. Includes project scaffolding, code quality analysis, architecture patterns, and complete tech stack guidance. Use when building new projects, analyzing code quality, implementing design patterns, or setting up development workflows.

35110

command-name

anthropics

This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.

697

python-project-structure

wshobson

Python project organization, module architecture, and public API design. Use when setting up new projects, organizing modules, defining public interfaces with __all__, or planning directory layouts.

860

app-builder

davila7

Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.

1645

Search skills

Search the agent skills registry