Three.js Game Skills: Building Browser Games with an AI Agent Director

What the Director Skill Solves and Who It Is For

Three.js Game Skills targets developers who use Codex or Claude Code as their primary coding agents and want to produce browser games in Three.js without manually coordinating which specialist to invoke for each task. Without a coordinator, a developer using an AI agent to build a game must specify at each step whether the agent should focus on rendering, physics, UI layout, or audio. The director skill takes that routing decision away from the user. It receives a high-level outcome description, determines which sibling skills apply, and delegates work accordingly.

The package is described as self-contained. It ships with nine skills covering gameplay systems, AAA-style graphics, UI, a debug and profiling workflow, a QA and release workflow, 3D asset generation, image generation, and audio generation. The ninth skill is the director itself. A Vite, TypeScript, and Three.js scaffold is bundled inside the relevant skill folders and used internally when starting from an empty project folder. The package does not teach Three.js to the developer; it teaches the agent how to build Three.js games correctly.

Five demo games are listed in the README, each with a public URL and a video linked from the author's X account: Neon Ridge Drift, Championship Snooker Arena, Starship Dogfight, Tide Singer, and Ripcore. These demonstrate the kind of output the director workflow is designed to produce. The repository has no GitHub releases and its primary language is Python, which drives the helper and validation scripts rather than the games themselves.

Installing on Codex and Claude Code

The recommended install path uses the skills CLI via npx. To install all nine skills globally for Codex, run:

npx skills add majidmanzarpour/threejs-game-skills --skill '*' -a codex -g -y

For Claude Code:

npx skills add majidmanzarpour/threejs-game-skills --skill '*' -a claude-code -g -y

If the installed skills CLI does not support one of these targets, the repository provides a local installer. Clone the repository and run one of the following:

./install.sh --codex
./install.sh --claude
./install.sh --all

The local installer copies the skills directory into the selected agent's skills directory. It skips any skill already present unless you pass `--force`. To overwrite existing skills:

./install.sh --codex --force

The `--prune-managed` flag removes managed skills that are no longer present in the source, but it never removes unrelated user skills. Once installed, Claude Code discovers skills from `~/.claude/skills` and Codex from `~/.agents/skills`. The directory targeted by the local installer differs from the npx path, so installing both ways may create duplicate copies. The README warns against having duplicate copies in both roots.

Invoking the Director and Scoping a Build

After installing, open Codex or Claude Code in an empty project folder or in an existing Three.js game. The README gives this example prompt:

Use threejs-game-director to build a premium futuristic tower defense game from scratch.
Automatically use the relevant gameplay, graphics, UI, asset generation, audio, debug,
and QA skills. Build a playable loop first, then iterate until it passes browser,
mobile, visual, UI, performance, and release checks.

In Claude Code, invoke the director with `/threejs-game-director` or name it in a prompt. In Codex, use `$threejs-game-director` or name it naturally. Both runners use the same SKILL.md files and discover sibling skills automatically once they are installed.

The director is designed to preserve art direction and scope through a build. It maintains a compact project note covering constraints, completed work, pending asset jobs, and next actions, so that corrections do not restart completed generation. For a small fix such as a HUD update, it limits verification to what changed. For a full game, it runs a complete production pass including real input simulation, screenshots, canvas pixel checks, and supported viewports.

QA Infrastructure and Playwright Integration

The package includes a QA and release skill that works with bundled scaffold and helper scripts. Generated games ship with deterministic test hooks, a seeded random number generator, and Playwright templates for three test types: smoke tests, visual-regression baselines, and bot playtests.

The scripts directory contains Python and Node.js helpers that the skills invoke internally. The README notes that users generally should not need to run scaffold or QA helper scripts directly. They are packaged for agent use as part of the workflow, not as standalone developer tools.

The package.json exposes the validation and test commands:

npm run validate:skills
npm run test:helpers

The `validate:skills` script runs a shell validator against the skills directory. The `test:helpers` script runs Python unit tests under `scripts/tests` and Node.js tests alongside them. A Python syntax checker is included and runs against all Python scripts in the package. These commands are for package development and verification, not for individual game projects.

Optional External Asset APIs

The core Three.js skills generate procedural and local assets and do not require any paid API keys. Three optional skills connect to external providers when keys are present. The `threejs-3d-generator` skill uses the Tripo API, configured through the `TRIPO_API_KEY` environment variable, to generate text-to-3D, image-to-3D, and multiview-to-3D models in GLB and FBX formats. The `threejs-image-generator` skill uses the Gemini image API, configured through `GEMINI_API_KEY`, for concept art, texture references, and GUI art. An audio generation skill exists as well, though its provider details were not listed in the portion of the README available.

The director handles missing or exhausted keys without stopping the build. When a key is absent or credits are depleted, it continues with procedural or local assets and reports the limitation. Temporary failures trigger bounded recovery of the current job rather than an immediate downgrade or a duplicate paid submission. The README is explicit that API keys must never be committed to version control or included in browser-side game code. The skills access provider APIs from local agent tooling and save generated assets into the project.

Limitations and Wrong-Tool Cases

The package does not provide a hosted model, API quota, or any runtime compute of its own. Installing the skills does not enable API features or change model settings. Capabilities such as background tools, subagents, native async execution, and reasoning settings depend entirely on the host agent runner. If the runner does not support a capability the director attempts to use, the agent works directly without that capability.

The skills are written for Three.js specifically. They are not general-purpose game-development skills and do not target other engines or frameworks such as Unity, Godot, or Phaser. A developer building a non-Three.js game in the browser would need different tooling.

The npx install path and the local `./install.sh` path write to different directories. Installing both creates duplicate skill copies, which the README explicitly warns against. On older versions of the skills CLI that do not recognize the `-a codex` or `-a claude-code` targets, the local installer is the correct fallback. The package has no GitHub releases; it distributes directly from the main branch.

Maintenance and License

The last push to the repository was on 2026-09-05. The package version is 0.1.0 and is marked private. The license is MIT, which permits use, modification, and redistribution without restriction, subject to the attribution clause.

The repository is not archived. The author, Majid Manzarpour, is identified in the README with a link to their X account. The project has no formal changelog, versioning documentation, or issue tracker policies visible in the available repository layout.

Editorial conclusion

Three.js Game Skills is a practical fit for developers who want an AI agent to handle the full production lifecycle of a Three.js browser game, from initial scaffold through QA, without writing agent orchestration themselves. It is not useful without Codex or Claude Code, and it does not provide a hosted model or API quota of its own. Before adopting it, verify that your agent runner supports the skills discovery path it targets, because the local installer and the npx path address different directories.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. majidmanzarpour/threejs-game-skills on GitHub
4. README