Threejs Game Director

Three.js Game Director

Purpose

Own the end-to-end game outcome. Build the playable loop, route through the right phases, verify evidence, and do not call prototype-quality work premium.

Claude Compatibility Rule

Claude-style skill runners may invoke only this skill when the user runs /threejs-game-director. Do not claim other skills were invoked unless the runner actually invoked them. For broad work, you must still try to load the sibling public SKILL.md files with filesystem read tools before planning or editing, then load each phase's required reference files before that phase starts. If a sibling SKILL.md cannot be loaded, then use references/director-phase-os.md as the fallback for that phase and record the failure.

Mandatory Sibling Skill Loading

For complete, premium, AAA, polished, high-fidelity, showcase, from-scratch, upgrade, or release-ready game work, load these sibling skill files before implementation:

• threejs-gameplay-systems/SKILL.md
• threejs-aaa-graphics-builder/SKILL.md
• threejs-game-ui-designer/SKILL.md
• threejs-debug-profiler/SKILL.md
• threejs-qa-release/SKILL.md

For premium, AAA, high-fidelity, showcase, complete, release-ready, or "less basic" game work, load this skill when the game includes or should include high-value 3D assets: generated 3D models, rigging, animation, textured imported assets, characters, creatures, bosses, buildings, vehicles, ships, weapons, signature props, complex pickups, or hero environment pieces. Do this before deciding whether procedural Three.js is enough:

• threejs-3d-generator/SKILL.md

For premium, AAA, high-fidelity, showcase, complete, release-ready, or "less basic" game work, load this skill when the game includes or should include concept/reference images, texture references, material references, skies/backgrounds, logos, marks, icons, decals, GUI art, title/menu art, terrain/sky plates, or 2D images for image-to-3D input. Do this before deciding those assets are not needed:

• threejs-image-generator/SKILL.md

For premium, AAA, high-fidelity, showcase, complete, release-ready, or "less basic" game work, load this skill when the game includes or should include SFX, ambience, UI sounds, interaction audio, vehicle/weapon/boss sounds, announcer/dialogue, scratch-performance voice conversion, or audio cleanup. Do this before deciding generated audio is not needed:

• threejs-audio-generator/SKILL.md

Try paths in this order:

1. Sibling installed path: ../<skill-name>/SKILL.md 2. Claude default path: ~/.claude/skills/<skill-name>/SKILL.md 3. Codex default path: ~/.codex/skills/<skill-name>/SKILL.md 4. General agents path: ~/.agents/skills/<skill-name>/SKILL.md 5. Repository source path: skills/<skill-name>/SKILL.md

If the file-read tool requires absolute paths, expand ~ to the user's home directory before reading.

For narrow director-invoked work, load the directly relevant sibling skill and threejs-qa-release. For broad game creation or premium iteration, load all five. Do not skip sibling loading just because this director contains a summarized phase OS.

External Asset Sourcing Gate

Do not decide "3D generator not needed", "image generator not needed", or "audio generator not needed" before loading the relevant skill files when the trigger categories above are present.

Before claiming an API key is unavailable, run the credential probe and paste its literal output in the report:

bash <director-skill-dir>/scripts/probe_asset_credentials.sh

Expected output shape:

TRIPO_API_KEY=SET|MISSING
GEMINI_API_KEY=SET|MISSING
ELEVENLABS_API_KEY=SET|MISSING

The probe sources the user's shell profiles and prints only SET/MISSING markers, never secret values. key unavailable is not a valid skip reason unless this probe output is shown.

For broad or premium game work, create an asset sourcing ledger before the graphics phase:

External asset sourcing:
- Credential probe output:
- Hero/player:
- Enemies/vehicles/weapons:
- Signature props/pickups:
- World/sky/background:
- Materials/textures/decals:
- Logos/icons/GUI art:
- Chosen sources per surface: procedural / threejs-image-generator / threejs-3d-generator / hybrid
- 3D generator loaded: yes/no, path or blocker:
- Image generator loaded: yes/no, path or blocker:
- Audio generator loaded: yes/no/not-needed, path or blocker:
- External assets generated: yes/no, outputs or reason:
- Audio assets generated: yes/no/not-needed, outputs or reason:

Allowed reasons to skip actual external generation after loading the skills:

• The user explicitly requested no external AI/assets or offline-only output.
• Credential probe output shows the relevant key is MISSING.
• A real API/network/quota error occurs after an attempted generation command; include the command and error summary.
• The surface is a repeated low-value prop better handled by instancing/procedural kits.
• A non-hero repeated/support surface is already scoring 2+ in the visual scorecard and the asset sourcing ledger explains why external generation would not improve the active screenshot.

If the game includes vehicles, ships, characters, creatures, weapons, buildings, sky/background art, logos/icons, decals, GUI art, or audio/SFX/voice needs, not-needed is not a valid ledger entry until the relevant generator skill has been loaded and the asset sourcing ledger explains the tradeoff. For premium claims, at least one high-value visual asset surface should use threejs-image-generator, threejs-3d-generator, or a documented hybrid unless an allowed skip reason blocks it.

For premium claims with hero surfaces such as player, enemy, boss, creature, vehicle, ship, weapon, building, or signature prop, procedural-only is not an allowed final answer unless the credential probe or attempted generation shows a real blocker. At least one hero/high-value asset must have real external evidence: a 3D generator task ID, downloaded GLB/GLTF/FBX path, image generator output path, or documented hybrid chain. For premium claims that include active gameplay, audio-only omission must be reported as a remaining gap unless the user explicitly asked for silent/offline output or ELEVENLABS_API_KEY is blocked.

Mandatory Reference Gate

References are not optional enrichment. They are phase-entry gates. For broad game creation, premium/AAA/showcase/polish requests, release-ready work, or any task that claims high visual quality, load the applicable reference files before implementation in that phase.

Required phase references:

• Gameplay systems: threejs-gameplay-systems/references/gameplay-workflows.md
• Physics selection, when physics/collision-heavy gameplay is in scope: threejs-gameplay-systems/references/physics-engine-selection.md
• New game completion checklist, when creating a game or first playable slice: threejs-gameplay-systems/references/checklists/new-game-definition-of-done.md
• Endless runner checklist, when building or upgrading an endless runner: threejs-gameplay-systems/references/checklists/endless-runner-premium-quality.md
• AAA graphics: threejs-aaa-graphics-builder/references/visual-scorecard.md
• AAA graphics: threejs-aaa-graphics-builder/references/implementation-blueprint.md
• AAA graphics: threejs-aaa-graphics-builder/references/model-recipes.md
• AAA graphics: threejs-aaa-graphics-builder/references/render-recipes.md
• AAA graphics checklists, for premium/AAA/showcase claims: threejs-aaa-graphics-builder/references/checklists/aaa-game-quality-gate.md and threejs-aaa-graphics-builder/references/checklists/aaa-visual-scorecard.md
• UI: threejs-game-ui-designer/references/ui-patterns.md
• UI checklists, when UI/HUD/menu/touch layout is in scope: threejs-game-ui-designer/references/checklists/game-ui-quality.md, threejs-game-ui-designer/references/checklists/hud-readability.md, and threejs-game-ui-designer/references/checklists/responsive-ui-fit.md
• Debug/profile: threejs-debug-profiler/references/debug-profile-checklists.md
• Debug/profile checklists, when debugging or profiling: threejs-debug-profiler/references/checklists/scene-debugging.md or threejs-debug-profiler/references/checklists/performance-profile.md
• QA/release: threejs-qa-release/references/qa-release-checklists.md
• QA/release checklists, for final verification: threejs-qa-release/references/checklists/visual-verification.md, threejs-qa-release/references/checklists/playtest-qa.md, and threejs-qa-release/references/checklists/release.md
• 3D generator, when loaded by the external asset sourcing gate: threejs-3d-generator/references/api-notes.md
• 3D generator, when loaded for a game: threejs-3d-generator/references/threejs-integration.md
• 3D plus image generator, when both are loaded: threejs-3d-generator/references/image-generator-workflows.md
• Audio generator, when loaded for a game: threejs-audio-generator/references/audio-workflows.md

Prompt templates are packaged in references/prompt-templates.md under the director and relevant sibling skills. Load them only when the user asks for a reusable prompt or task template.

Try reference paths in this order:

1. Relative to the loaded skill path: <loaded-skill-dir>/references/<file>.md 2. Claude default path: ~/.claude/skills/<skill-name>/references/<file>.md 3. Codex default path: ~/.codex/skills/<skill-name>/references/<file>.md 4. General agents path: ~/.agents/skills/<skill-name>/references/<file>.md 5. Repository source path: skills/<skill-name>/references/<file>.md

Rules:

• Load references at phase entry, not at the end.
• Track every required reference in the reference ledger with yes/no, path, and failure reason.
• A phase cannot be marked done until its required references are loaded or the final answer explicitly reports the reference as unavailable and the phase as blocked/fallback.
• For premium/AAA/showcase claims, the final response must include the filled 10-category visual scorecard from visual-scorecard.md, including average and automatic failures remaining.
• For broad work, include the phase checklist outputs from each relevant reference, not just a summary that the game works.
• Thorough mode is the default for broad, premium, AAA, showcase, complete, and release-ready requests. Economy mode is allowed only for narrow fixes that do not claim premium quality.

If Task/subagent/workflow tools are available, delegate each major phase to a focused worker with the phase SKILL.md plus its required references explicitly loaded. If those tools are unavailable, execute serially after the same reference files have been loaded.

Ledgers

Track both skill loading and phase execution:

• Director: active
• Sibling skills loaded:
• Gameplay systems: yes/no, path or reason:
• AAA graphics: yes/no, path or reason:
• UI: yes/no, path or reason:
• Debug/profile: yes/no, path or reason:
• QA/release: yes/no, path or reason:
• 3D generator: yes/no/not-needed, path or reason:
• Image generator: yes/no/not-needed, path or reason:
• Audio generator: yes/no/not-needed, path or reason:
• External asset sourcing:
• Credential probe output:
• Hero/player source:
• Enemies/vehicles/weapons source:
• Signature props/pickups source:
• World/sky/background source:
• Materials/textures/decals source:
• Logos/icons/GUI art source:
• Audio/SFX/voice source:
• External assets generated or skip reason:
• Audio assets generated or skip reason:
• Required references loaded:
• Gameplay workflows: yes/no/not-needed, path or reason:
• Physics engine selection: yes/no/not-needed, path or reason:
• Gameplay/new-game checklists: yes/no/not-needed, path or reason:
• Visual scorecard: yes/no/not-needed, path or reason:
• Graphics implementation blueprint: yes/no/not-needed, path or reason:
• Model recipes: yes/no/not-needed, path or reason:
• Render recipes: yes/no/not-needed, path or reason:
• Graphics checklists: yes/no/not-needed, path or reason:
• UI patterns: yes/no/not-needed, path or reason:
• UI checklists: yes/no/not-needed, path or reason:
• Debug/profile checklists: yes/no/not-needed, path or reason:
• QA/release checklists: yes/no/not-needed, path or reason:
• 3D generator API notes: yes/no/not-needed, path or reason:
• 3D generator Three.js integration: yes/no/not-needed, path or reason:
• 3D/image generator workflows: yes/no/not-needed, path or reason:
• Audio workflows: yes/no/not-needed, path or reason:
• Gameplay systems: pending/running/done/skipped, evidence:
• External asset sourcing: pending/running/done/skipped, evidence:
• AAA graphics: pending/running/done/skipped, evidence:
• UI: pending/running/done/skipped, evidence:
• Debug/profile: pending/running/done/skipped, evidence:
• QA/release: pending/running/done/skipped, evidence:

A phase is done only with implementation plus verification evidence.

Phase Routing

• threejs-gameplay-systems: first playable slice, architecture, mechanics, entities, input, camera, controls, game feel.
• Physics selection: engine choice, fixed timestep, collider strategy, sensors, collision proxies, CCD, diagnostics, and QA for physics-heavy games.
• External asset sourcing: credential probe, generator skill loading, asset source decision, task IDs/output files or blocker evidence. This phase must be done before threejs-aaa-graphics-builder can be marked done for premium graphics work.
• threejs-aaa-graphics-builder: basic-looking screenshots, asset architecture, models, materials, VFX, lighting/render, visual scorecard.
• threejs-game-ui-designer: HUDs, menus, overlays, responsive UI, icons, safe areas, UI states.
• threejs-debug-profiler: blank canvas, render/runtime bugs, loading, resize, mobile input/render bugs, performance profiling.
• threejs-qa-release: browser QA, screenshots, canvas pixels, responsive checks, production build, preview, release notes.
• threejs-3d-generator: external AI-generated models, GLB/FBX outputs, text/image-to-3D, texturing, auto-rigging, animation, conversion.
• threejs-image-generator: 2D concept/reference images, image-to-model inputs, textures, sky/backgrounds, logos, icons, GUI elements, decals.
• threejs-audio-generator: generated SFX, looping ambience, UI sounds, voice/TTS, voice conversion, cleanup/isolation, and game audio runtime planning.

If a sibling skill file is loaded, follow its workflow for that phase. If it is unavailable, record the missing path/reason and use references/director-phase-os.md for that phase.

Packaged Runtime Resources

For new projects, use the gameplay skill's packaged scaffold creator:

python3 <threejs-gameplay-systems-skill-dir>/scripts/create_threejs_game.py ./my-game

For canvas inspection, use the generated game's npm run inspect:canvas when available, or the QA skill's packaged inspector:

node <threejs-qa-release-skill-dir>/scripts/inspect-threejs-canvas.mjs --url http://127.0.0.1:5188

Premium Completion Rule

For premium, AAA, polished, complete, release-ready, or showcase requests, completion requires visible quality across gameplay, hero/player, obstacles/enemies, rewards/interactables, world kit, HUD/menu states, render/lighting/materials, feel, performance/mobile, and QA.

If screenshots are dominated by primitives, flat roads/arenas, generic stat cards, sparse worlds, or glow-only detail, the task is not done.

The scorecard must use the exact categories from threejs-aaa-graphics-builder/references/visual-scorecard.md: Art direction, Hero/player, Obstacles/enemies, Rewards/interactables, World/environment, Materials/textures, Lighting/render, VFX/motion, UI/HUD, and Performance evidence. Do not substitute a personal rubric.

Required Verification

• Build/typecheck.
• Local browser run.
• Console/page error check.
• Active desktop and mobile screenshots.
• Nonblank canvas pixel evidence.
• Main input/objective/fail or restart path.
• Visual scorecard for premium/AAA claims.
• External asset sourcing ledger for premium/AAA or less-basic graphics claims.
• Credential probe output and real external asset outputs or blocker evidence for premium/AAA asset-category claims.
• Audio matrix/generated audio evidence or a reported blocker for premium active gameplay claims.
• Renderer diagnostics when graphics changed.
• Final ledger with evidence and remaining blockers.

Report Audit

When shell tools are available, draft the final evidence report to a temporary markdown file and run the director audit before finalizing broad or premium work:

python3 <director-skill-dir>/scripts/audit_reference_report.py --premium /path/to/final-report.md

Use --premium for premium, AAA, showcase, high-fidelity, polished, complete, release-ready, or "less basic" claims. Add --physics for physics-heavy games such as pool/snooker, mini-golf, pinball, marble racers, physics puzzles, rigid-body games, or games with many sensors/colliders. Add --audio when generated or integrated audio is in scope, and for premium active-gameplay claims unless the user requested silent/offline-only output. If the audit fails, fix the missing report sections or state the exact blocker instead of claiming completion. If the script is unavailable, manually enforce the same required sections: skill-loading ledger, reference ledger, external asset/audio sourcing ledger, phase checklist, visual scorecard, physics/audio diagnostics when relevant, verification evidence, and remaining risks.

Final Response

Report the skill-loading ledger, reference ledger, external asset sourcing ledger, phase ledger, files changed, run URL, controls, verification commands, screenshots/artifacts, renderer/performance notes, quality gates passed, skipped phases, and remaining risks. For premium/AAA/showcase claims, include the filled visual scorecard and automatic failures remaining. Be precise: "invoked" means a slash/tool skill invocation; "loaded" means the SKILL.md or reference file was read into context; "executed phase" means the work was performed under either loaded skill guidance or the director fallback.

Director Phase OS

Use this reference only after threejs-game-director has attempted to load the relevant sibling public skill files and one or more files were unavailable. This file is the fallback operating system, not a reason to skip sibling skill loading.

Non-Negotiable Rules

• Do not claim another public skill was invoked unless its SKILL.md was actually loaded or the runner explicitly invoked it.
• For broad game work, try to load all five sibling public skill files before implementation: gameplay systems, AAA graphics, UI designer, debug profiler, and QA release.
• When external 3D assets would help, also try to load threejs-3d-generator; when 2D concepts/textures/UI art would help, also try to load threejs-image-generator; when SFX/ambience/voice would help, also try to load threejs-audio-generator.
• For premium/AAA/showcase/high-fidelity/less-basic work with vehicles, ships, characters, creatures, weapons, buildings, signature props, skies/backgrounds, textures, decals, logos, icons, GUI art, SFX, ambience, or voice, load the relevant generator skill before deciding it is not needed.
• Before claiming a missing generator credential, run the director credential probe and paste the literal SET/MISSING output.
• Record an external asset sourcing ledger before the graphics phase.
• Record sibling skill loading paths or failure reasons in the ledger.
• Load each phase's required reference files at phase entry. Do not defer references until final judgment.
• Record every required reference path or failure reason in the reference ledger.
• A phase cannot be marked done if its required references were skipped.
• A broad game request is not complete after a first playable slice when the user asked for premium, AAA, polished, showcase, complete, release-ready, or "less basic".
• Keep an execution ledger with phases, evidence, skipped work, and blockers.
• Prefer a small authored vertical slice over a larger placeholder scene.
• Treat primitive-dominant models, box skylines, flat arenas, generic stat-card HUDs, and glow/fog-only detail as prototype placeholders.
• Verify through browser evidence before calling the game done.

External Asset Sourcing Gate

For broad or premium game work, fill this before the graphics phase:

External asset sourcing:
- Credential probe output:
- Hero/player:
- Enemies/vehicles/weapons:
- Signature props/pickups:
- World/sky/background:
- Materials/textures/decals:
- Logos/icons/GUI art:
- Audio/SFX/voice:
- Chosen sources per surface: procedural / threejs-image-generator / threejs-3d-generator / threejs-audio-generator / hybrid
- 3D generator loaded: yes/no, path or blocker:
- Image generator loaded: yes/no, path or blocker:
- Audio generator loaded: yes/no/not-needed, path or blocker:
- External assets generated: yes/no, outputs or reason:
- Audio assets generated: yes/no/not-needed, outputs or reason:

Allowed reasons to skip actual external generation after loading the relevant skills:

• The user explicitly requested no external AI/assets or offline-only output.
• Credential probe output shows the relevant key is MISSING.
• A real API/network/quota error occurs after an attempted generation command; include the command and error summary.
• The surface is a repeated low-value prop better handled by instancing/procedural kits.
• A non-hero repeated/support surface is already scoring 2+ and the ledger explains why external generation would not improve the active screenshot.

Do not write not-needed for generator skills before loading the relevant skill when trigger surfaces are present.

For premium claims with hero surfaces such as player, enemy, boss, creature, vehicle, ship, weapon, building, or signature prop, procedural-only is not an allowed final answer unless the credential probe or attempted generation shows a real blocker. At least one hero/high-value asset must have real external evidence: a 3D generator task ID, downloaded GLB/GLTF/FBX path, image generator output path, or documented hybrid chain. For premium active gameplay, missing audio assets must be reported as a remaining gap unless the user requested silent/offline-only output or the audio credential/API attempt is blocked.

Required References

Load these files before the matching phase starts:

• Gameplay systems: threejs-gameplay-systems/references/gameplay-workflows.md
• Physics selection, when physics/collision-heavy gameplay is in scope: threejs-gameplay-systems/references/physics-engine-selection.md
• New-game checklist, when creating a game or first playable slice: threejs-gameplay-systems/references/checklists/new-game-definition-of-done.md
• Endless runner checklist, when building or upgrading an endless runner: threejs-gameplay-systems/references/checklists/endless-runner-premium-quality.md
• AAA graphics: threejs-aaa-graphics-builder/references/visual-scorecard.md
• AAA graphics: threejs-aaa-graphics-builder/references/implementation-blueprint.md
• AAA graphics: threejs-aaa-graphics-builder/references/model-recipes.md
• AAA graphics: threejs-aaa-graphics-builder/references/render-recipes.md
• AAA graphics checklists, for premium/AAA/showcase claims: threejs-aaa-graphics-builder/references/checklists/aaa-game-quality-gate.md and threejs-aaa-graphics-builder/references/checklists/aaa-visual-scorecard.md
• UI: threejs-game-ui-designer/references/ui-patterns.md
• UI checklists, when UI/HUD/menu/touch layout is in scope: threejs-game-ui-designer/references/checklists/game-ui-quality.md, threejs-game-ui-designer/references/checklists/hud-readability.md, and threejs-game-ui-designer/references/checklists/responsive-ui-fit.md
• Debug/profile: threejs-debug-profiler/references/debug-profile-checklists.md
• Debug/profile checklists, when debugging or profiling: threejs-debug-profiler/references/checklists/scene-debugging.md or threejs-debug-profiler/references/checklists/performance-profile.md
• QA/release: threejs-qa-release/references/qa-release-checklists.md
• QA/release checklists, for final verification: threejs-qa-release/references/checklists/visual-verification.md, threejs-qa-release/references/checklists/playtest-qa.md, and threejs-qa-release/references/checklists/release.md
• 3D generator, when loaded by the external asset sourcing gate: threejs-3d-generator/references/api-notes.md
• 3D generator, when loaded for a game: threejs-3d-generator/references/threejs-integration.md
• 3D plus image generator, when both are loaded: threejs-3d-generator/references/image-generator-workflows.md
• Audio generator, when loaded for a game: threejs-audio-generator/references/audio-workflows.md

Try paths relative to the loaded skill directory first, then ~/.claude/skills, ~/.codex/skills, ~/.agents/skills, and finally repository skills.

Phase Ledger Template

Director: active
Sibling skill files loaded:
- Gameplay systems: yes/no, path or reason:
- AAA graphics: yes/no, path or reason:
- UI: yes/no, path or reason:
- Debug/profile: yes/no, path or reason:
- QA/release: yes/no, path or reason:
- 3D generator: yes/no/not-needed, path or reason:
- Image generator: yes/no/not-needed, path or reason:
- Audio generator: yes/no/not-needed, path or reason:
External asset sourcing:
- Credential probe output:
- Hero/player source:
- Enemies/vehicles/weapons source:
- Signature props/pickups source:
- World/sky/background source:
- Materials/textures/decals source:
- Logos/icons/GUI art source:
- Audio/SFX/voice source:
- External assets generated or skip reason:
- Audio assets generated or skip reason:
Required references loaded:
- Gameplay workflows: yes/no/not-needed, path or reason:
- Physics engine selection: yes/no/not-needed, path or reason:
- Gameplay/new-game checklists: yes/no/not-needed, path or reason:
- Visual scorecard: yes/no/not-needed, path or reason:
- Graphics implementation blueprint: yes/no/not-needed, path or reason:
- Model recipes: yes/no/not-needed, path or reason:
- Render recipes: yes/no/not-needed, path or reason:
- Graphics checklists: yes/no/not-needed, path or reason:
- UI patterns: yes/no/not-needed, path or reason:
- UI checklists: yes/no/not-needed, path or reason:
- Debug/profile checklists: yes/no/not-needed, path or reason:
- QA/release checklists: yes/no/not-needed, path or reason:
- 3D generator API notes: yes/no/not-needed, path or reason:
- 3D generator Three.js integration: yes/no/not-needed, path or reason:
- 3D/image generator workflows: yes/no/not-needed, path or reason:
- Audio workflows: yes/no/not-needed, path or reason:
Gameplay systems: pending/running/done/skipped - evidence:
External asset sourcing: pending/running/done/skipped - evidence:
AAA graphics: pending/running/done/skipped - evidence:
UI: pending/running/done/skipped - evidence:
Debug/profile: pending/running/done/skipped - evidence:
QA/release: pending/running/done/skipped - evidence:

Mark a phase done only after implementation plus verification. If a phase is skipped, state why it is out of scope or blocked.

Phase 1: Discovery And Playable Contract

• Inspect package scripts, dependencies, app structure, renderer setup, loop ownership, input, camera, UI, diagnostics, and existing screenshots.
• Define the one-sentence loop: player verb, objective, pressure, reward, fail state, restart.
• Define target devices and performance budget. If absent, assume desktop plus mobile browser, WebGL/WebGL2 fallback, and capped DPR.
• Identify the highest-risk surfaces: blank/broken canvas, no playable loop, weak controls, basic graphics, unreadable UI, or unverified release.

Exit evidence:

• Current scripts/dependencies known.
• Playable loop stated.
• Phase ledger initialized.

For a new project, use the gameplay skill's packaged scaffold creator:

python3 <threejs-gameplay-systems-skill-dir>/scripts/create_threejs_game.py ./my-game

Phase 2: Gameplay Systems

Build or repair the playable loop before visual depth.

• Add renderer, scene, camera, resize, update loop, input intents, state machine, entities, collision or physics, scoring/progression, fail/retry, HUD state, audio/VFX hooks, and diagnostics.
• If the game is physics-heavy, load the physics selection reference, choose an engine explicitly, and prefer Rapier for robust browser physics unless the task fits custom collision or a small cannon-es fallback.
• Keep ownership boundaries clear: core, game, entities, systems, assets, ui, tests.
• Tune movement, camera follow, FOV, acceleration, cooldowns, difficulty, and restart through short play loops.
• Keep collision proxies simpler than detailed meshes.
• Avoid multiple animation loops, duplicated state, and per-frame allocations in hot paths.

Exit evidence:

• Build/typecheck passes.
• Browser opens with nonblank canvas.
• Main control path changes state.
• Objective or score progresses.
• Fail/retry path exists when relevant.
• Physics engine choice, timestep, collider strategy, and diagnostics are reported when physics is in scope.
• New-game checklist outcome is reported for new games or first playable slices.

Phase 3: External Asset Sourcing

Run before the premium graphics pass when trigger surfaces exist.

• Run the credential probe from the director skill scripts and paste output.
• Load threejs-3d-generator, threejs-image-generator, and/or threejs-audio-generator when their trigger surfaces exist.
• Load 3D generator API notes, Three.js integration, image-generator workflow, and audio workflow references when relevant.
• Decide source per high-value surface: procedural / threejs-image-generator / threejs-3d-generator / threejs-audio-generator / hybrid.
• Generate at least one high-value external output for premium hero surfaces unless the probe or attempted generation shows a real blocker.
• Record 3D generator task IDs, downloaded GLB/GLTF/FBX paths, image generator output paths, audio output paths, or blocker evidence.

Exit evidence:

• Credential probe output.
• Skill/reference loading ledger for generator skills.
• Asset sourcing ledger.
• External outputs or blocker evidence.

Phase 4: AAA Graphics

Use when screenshots look basic or the user asks for premium quality.

• Score active-play screenshot across art direction, hero/player, obstacles/enemies, rewards/interactables, world/environment, materials/textures, lighting/render, VFX/motion, UI/HUD, and performance evidence.
• Add production graphics architecture: material library, procedural textures, decals, model factories, world prop kit, VFX system, lighting/render pipeline, diagnostics.
• Upgrade all visible surfaces, not only the player: hero, hazards, rewards, ground/track/arena, foreground props, background layers, interactable telegraphs, material variation, and state VFX.
• Use threejs-image-generator for concept/reference images, texture references, logos, icons, decals, skies, and image-to-3D inputs when 2D source art would improve quality.
• Use threejs-3d-generator for high-value 3D assets such as characters, creatures, vehicles, buildings, weapons, hero props, pickups, bosses, rigging, animation, texture, and conversion when procedural code is not enough.
• Use threejs-audio-generator for SFX, ambience loops, UI sounds, voice, conversion, and cleanup when generated audio would improve the playable loop.
• If trigger surfaces exist, complete the external asset sourcing phase before deciding procedural code is enough.
• Build authored forms with bevels, extrusions, curves, tubes, lathes, custom geometry, decals, trim, panel lines, repeated detail via instancing, and collision proxies.
• Add lighting, tone mapping, shadows/contact, fog/depth, post-processing, and bloom only after the authored forms exist.

Exit evidence:

• Before/after scorecard.
• Filled categories from visual-scorecard.md: Art direction, Hero/player, Obstacles/enemies, Rewards/interactables, World/environment, Materials/textures, Lighting/render, VFX/motion, UI/HUD, Performance evidence.
• Average score and automatic failures remaining.
• Active desktop and mobile screenshots.
• Renderer diagnostics: calls, triangles, geometries, textures, and material count when possible.
• Imported asset diagnostics when generated 3D was used: task IDs, file paths, file size, scale/bounds, collision proxy, animation clips, triangles/materials/textures when possible.
• No scorecard category below 2 for premium claims.

Phase 5: UI

Use when HUD/menu/interface craft affects quality or readability.

• Inventory gameplay, pause, settings, fail/retry, milestone/win, loading/error, and touch states.
• Replace utility stat-card grids with game-specific meters, compact clusters, icons, badges, alerts, cooldown rings, reticles, diegetic labels, and stateful overlays.
• Use stable dimensions, safe-area padding, fixed-width numeric fields, text fit, and responsive constraints.
• Wire UI to game state. Avoid duplicated game rules inside UI code.
• Ensure UI never blocks the player, threats, pickups, next decision, or critical touch controls.

Exit evidence:

• Desktop and mobile screenshots for relevant states.
• Text-fit and overlap check.
• Touch target and safe-area check when mobile is in scope.
• UI checklist outcomes are reported.

Phase 6: Debug And Profile

Use whenever the canvas is blank/broken, interaction fails, mobile behavior breaks, or visual changes add cost.

• Reproduce locally and read console/page/network errors.
• Check canvas CSS size and drawing-buffer size, renderer/context, loop ownership, camera, near/far, lights, fog, transforms, materials, loaders, asset paths, and resize behavior.
• For performance, measure production preview where possible: FPS/frame time, draw calls, triangles, geometries, materials, textures, memory, bundle, and expensive post/shadows.
• Optimize one bottleneck at a time using instancing, shared resources, culling, LOD, pooling, adaptive DPR, cheaper shadows/post, and explicit disposal.

Exit evidence:

• Root cause or measured bottleneck stated.
• Baseline/post metrics when optimizing.
• Broken path retested.

Phase 7: QA And Release

Use before calling broad work complete.

• Run build/typecheck.
• Start dev or preview server and open the correct URL.
• Check console/page/network errors.
• Capture active desktop and mobile screenshots.
• Sample canvas pixels for nonblank and varied output.
• Use the generated game's npm run inspect:canvas when available, or the QA skill's packaged inspector:

node <threejs-qa-release-skill-dir>/scripts/inspect-threejs-canvas.mjs --url http://127.0.0.1:5188

• Trigger main input, objective progression, fail/retry, and recent risky paths.
• Verify HUD text fit, safe areas, touch targets, resize, and mobile input.
• For release, verify production preview, base path, static assets, debug gating, bundle/large assets, and deployment assumptions.

Exit evidence:

• Commands run and pass/fail.
• URL used.
• Screenshots/artifact paths.
• Issues fixed or listed with likely owners.
• Residual risks.

Completion Gate

For premium/AAA/showcase claims, all of these must be true:

• Skill-loading ledger and reference ledger are present.
• External asset sourcing ledger is present for premium/AAA/showcase graphics work.
• Credential probe output plus external output evidence or blocker evidence is present for premium asset-category claims.
• Playable loop works through real input.
• Active-play screenshots exist for desktop and mobile.
• Visual scorecard has no category below 2 and average is at least 2.3.
• Visual scorecard uses the authored rubric, not an improvised rubric.
• HUD/menu states are readable and responsive.
• Renderer diagnostics exist after graphics changes.
• Build and browser QA passed or blockers are clearly reported.
• Physics-heavy games include engine choice, timestep, collider strategy, sensors, CCD use, and body/collider diagnostics.

If any gate fails, continue iterating or report the exact blocker instead of calling the game premium.

Three.js Game Director Prompt Templates

Reusable prompt templates packaged with this skill. Use only templates relevant to the current request, and adapt placeholders to the game/project context.

---

New Three.js Game Prompt

Use threejs-game-director for a complete or premium Three.js browser game. It should automatically route through gameplay systems, AAA graphics, UI, debug/profile, and QA/release phases.

Use threejs-gameplay-systems directly only when the requested output is explicitly a small first prototype or gameplay-system change.

Game idea:

• Core verb:
• Objective:
• Camera:
• Visual tone:
• Target devices:
• Time budget:

Requirements:

• Use TypeScript, Vite, and Three.js modules.
• Build a playable loop, not a static scene.
• Keep the first version small enough to verify quickly, then continue quality passes if the target is complete/premium.
• Include desktop keyboard input and mobile touch input when target devices include mobile.
• Add HUD feedback for objective, score, health, time, or state.
• For premium requests, replace prototype HUD/models/world detail with designed UI, procedural asset kits, and renderer diagnostics.
• Run build and visual verification before reporting done.

Final response:

• list files created or changed
• describe playable controls
• report build, browser, console, screenshot, canvas-pixel, and viewport evidence
• list remaining risks

---

AAA Three.js Game Pass Prompt

Use threejs-game-director to upgrade this Three.js browser game from prototype-quality to premium showcase quality.

Target:

• Genre:
• Core verb:
• Desired mood:
• Target devices:
• Performance budget:

Automatic skill flow:

• Use the director's active-play screenshot scorecard first if screenshots exist or can be captured.
• Use threejs-aaa-graphics-builder when screenshots still look basic or when multiple graphics surfaces are weak.
• Use threejs-game-ui-designer for HUD, menus, overlays, icons, text fit, and touch UI.
• Use threejs-gameplay-systems for speed, controls, camera, impact, difficulty, and restart loop.
• Use threejs-debug-profiler before and after expensive visual changes.
• Use threejs-qa-release before calling the pass complete.

Quality priorities:

• Prefer a smaller authored vertical slice over a larger placeholder game.
• Replace utility HUD boxes with designed, genre-specific interface states.
• Replace placeholder primitives with authored silhouettes and reusable procedural kits.
• Build a minimum premium asset set: hero/player, three obstacle/enemy variants, two reward/interactable variants, world prop kit, and material kit.
• Add depth layers, parallax, foreground/midground/background composition, and material contrast.
• Make rewards, threats, player state, and objectives readable during motion.
• Add feedback for speed, pickup, near miss, hit, fail, restart, streak, and milestone.
• Keep render cost visible through renderer diagnostics.

Prototype rejection tests:

• Main world is mostly stretched boxes or flat planes.
• Player/hero asset is mostly default primitives with glow.
• Obstacles/pickups are one repeated silhouette.
• HUD is mostly rectangular stat cards.
• Fog/darkness/bloom hides missing geometry.

Verification:

• Build and run locally.
• Capture desktop and mobile screenshots after interaction.
• Check console/page errors and nonblank canvas pixels.
• Check UI text fit, overlap, safe areas, and touch targets.
• Report draw calls, triangles, geometries, textures, and frame-time/FPS evidence when available.
• Compare against threejs-aaa-graphics-builder/references/checklists/aaa-game-quality-gate.md.
• Compare against threejs-aaa-graphics-builder/references/checklists/aaa-visual-scorecard.md.
• Do not report the task as premium-complete if any prototype rejection test still fails.

---

Premium Endless Runner Pass Prompt

Use threejs-game-director to upgrade this endless runner into a premium, high-fidelity browser game.

Current blockers: -

Runner-specific targets:

• Player avatar/vehicle silhouette:
• Obstacle families:
• Reward/readability language:
• World theme:
• Speed/impact feel:
• HUD states:

Required upgrades:

• Replace simple stat-card HUDs with a genre-specific runner HUD: compact status, readable progress, combo/streak, overdrive/boost, fail/retry, pause/settings.
• Replace cube obstacles and basic pickups with distinct procedural model families that read instantly at speed.
• Build at least three obstacle families, two reward variants, one detailed player vehicle/avatar, and one reusable track/city prop kit.
• Add route/lane detail, near-field props, mid-field silhouettes, far parallax, and speed lines that do not hide hazards.
• Improve player avatar/vehicle detail: layered chassis/body, trim, emissive signals, animation, trail/wake, and readable collision footprint.
• Add hazard telegraphing, pickup magnet/collect feedback, near-miss feedback, speed ramp cues, milestone gates, and crash/retry polish.
• Tune camera FOV, follow lag, shake, roll, and effects for speed without disorientation.

Avoid:

• Giant untextured skyline boxes as the main world detail.
• Glow as the only fidelity technique.
• HUD panels that look like debug readouts.
• Repeating the same obstacle silhouette too frequently.
• Effects that obscure the next lane decision.

Verification:

• Use threejs-gameplay-systems/references/checklists/endless-runner-premium-quality.md.
• Capture desktop and mobile screenshots during action, not only idle.
• Report renderer diagnostics for worst-case visible segment.
• Play long enough to see speed ramp, pickups, hazards, fail/retry, and any boost state.
• If the screenshot still reads as road plus boxes plus basic pickups, continue modeling/world/UI passes instead of reporting done.