Game Development

Six modes: Design (diagnosis, auditing, improvement), Pipeline (full lifecycle orchestration), Sprite (AI sprite generation), Phaser (2D engine builds), Unity (unity CLI, batch builds, tests, licensing), GM (large multi-system implementations). Cross-cutting concerns (audio, QA, deploy) load as needed. Classify the request and follow the matching section.

Mode Selection

If the request spans modes, load both primary references. Design + Pipeline is common (design an improvement then implement it). Sprite + Phaser is common (generate assets then wire into a Phaser game).

Design Mode

Evidence-led game design diagnosis with 61 runnable capabilities. Start from repository evidence; never guess when the repo can answer.

Workflow

1. Intake. Read target repository's governing files. Search for game, product, UI, analytics, and research guidance. Use file search to find design docs, player copy, rules, UI, config, tests, analytics, issues. Separate facts into: observed, documented, measured, inferred.
2. Ask only what the repo cannot answer. Which player moment matters? What external evidence exists (playtests, telemetry, reviews)? Which constraints bind (platform, phase, team, time)?
3. Load references. Route greedily -- load every module that could change the recommendation:

4. Diagnose. Trace the player path: cue -> interpretation -> choice -> response -> cost/reward -> feedback -> next intention. State player consequence, evidence, competing explanations, confidence, severity.
5. Decide. Offer 2-5 distinct options. For each: player-visible change, pillar fit, scope, dependencies, effort, reversibility, success metric, stop rule. Prefer reversible experiments. Reject dark patterns.
6. Completion gate. Every finding has evidence or is marked as inference. Every recommendation has a validation plan.

Discovery Mode

When request is bare "game design" or "what reviews are available": load references/capability-catalog.md and present the full domain-organized catalog of 61 capabilities.

Autonomous Improvement

When asked to improve a game's retention, churn, or engagement: load references/autonomous-improvement.md. Inspect the real game, run relevant capabilities, make the smallest safe reversible improvement, verify, leave a measurement plan.

Pipeline Mode

Full lifecycle orchestration: SCAFFOLD -> ASSETS -> DESIGN -> AUDIO -> QA -> DEPLOY. Each phase can be entered independently.

Entry Detection

Phase 1: SCAFFOLD

Detect engine (Three.js, Phaser, or vanilla canvas). Delegate to the appropriate engine skill or scaffold from template. A folder with ProjectSettings/ProjectVersion.txt is a Unity project: switch to Unity mode.

Phase 2: ASSETS

Route by asset type:

Phase 3: DESIGN

Add game feel: screen shake, particles, hit-stop, juice. Load references/game-feel-patterns.md.

Phase 4: AUDIO

Web Audio API patterns, AudioManager, AudioBridge. Load references/game-audio.md.

Phase 5: QA

Automated testing, visual regression, Playwright, canvas seams. Load references/game-qa.md.

Phase 6: DEPLOY

Sprite Mode

AI sprite generation: portrait, portrait-loop, spritesheet, per-row animated sheets. Load references/game-sprite-pipeline.md for the full pipeline.

Quick Steps

1. Detect format. Portrait (single image), portrait-loop (idle animation), spritesheet (action set), per-row (multiple animations in rows).
2. Select backend. Load references/backend-chain.md for dispatch: Codex CLI primary, Gemini fallback.
3. Select style. Load references/style-presets.md for 9 era/hardware presets.
4. Generate. Follow the pipeline for the detected format.
5. Post-process. Background removal, palette quantization, sheet assembly.
6. Validate. Check dimensions, frame counts, transparency, color consistency.

Phaser Mode

Phaser 3 2D game engine builds. Load references/phaser-gamedev.md for the full methodology.

Core Patterns

Load references/core-patterns.md for scene lifecycle, transitions, and input handling.

Unity Mode

Build, test, and inspect Unity projects from a terminal, with the unity CLI or classic Unity.exe -batchmode. Load the reference that matches the task:

Workflow

1. Locate. Find the folder that holds ProjectSettings/ProjectVersion.txt; it can sit below the repository root. Read m_EditorVersion.
2. Probe. Run unity --version, unity editors -i --json, and unity license status --json. Without the CLI, use classic Unity.exe; installing or upgrading software needs the user's OK.
3. Pick the tool from the table in references/unity-batchmode-builds.md.
4. Warn before launching. Batch runs can still bring Unity windows to the front, so tell the user before Unity starts on a desktop they are using, and group the runs.
5. Run headless with --timeout and a log file: --log-file for unity build, -- -logFile <path> for unity run; unity test logs to <project>/Logs/Editor.log. Check unity editors running --json first: one Editor per project folder.
6. Read the result. Branch on the exit code, then on errors[0].code, then on the log (error CS, Build Finished, Result:).
7. On a license error, follow references/unity-licensing.md before you retry. Signals: Unity.exe exit 198, or CLI exit 6 with 198 in errors[0].message.

GM Mode

Evidence-to-live implementation for large GM programs (multi-system, multi-wave, CPU-intensive). Load references/gm-brilliant-implementation.md for the full methodology.

Applicability Gate

GM mode applies only when: multiple interconnected game systems change, CPU performance is a concern, or the implementation spans multiple deployment waves. If the gate fails, route to quick, workflow, or the target project's skill.

Key References

Deep References

Load when the task needs detailed patterns, catalogs, or specifications.

Design

Pipeline

Sprite

Phaser

GM