Claude Code Game Kit

Make games with Claude Code that hold together. Every project gets the same commands, tests and habits on any of eight
engines (seven tested against their real toolchains; RPG Maker MZ is an untested proof of concept), so Claude builds, tests and checks your game instead of guessing. Free and open source (MIT).

New to this? Read START_HERE.md: install Claude Code and Python, open this folder in VS Code (or the Claude desktop app), open Claude Code and type Start. Claude interviews you about your game, writes a one-page game plan with you, then sets everything up. The steps below are the same thing done by hand.

Made with the kit

One small game per engine, plus a local-AI pair. Six were built using only what is in the kit, with bots that test their
main idea; every one comes with a step-by-step HOW_IT_WAS_MADE, including what went wrong. Click one.

Ghost Lantern, Web 2D (Phaser) Slip out of a crypt past ghosts that fear your lantern.	Courier Dash, Web 3D (Three.js) Deliver parcels past a patrol robot you can read.
Scrap Tanks, C++ and SDL2 Tank brawl against raiders on a behavior tree.	Graveyard Shift, Unity 6 Light the lantern or creep in the dark past NavMesh ghosts.
Rune Delve, Unreal Engine 5 Time your ward to the orc's swing: GAS spells, all C++.	Coyote Hop, Godot 4 A one-level platformer with a reachability-tested level.
Gatekeeper, Godot 4 and Web Talk past a guard run by a small AI model on your own machine.	Lockpick MZ, RPG Maker MZ A lockpicking minigame plugin: timing beats mashing. Untested proof of concept: built without MZ, tested in Node and a browser, never run in the engine.
Crimson Nebula, Bevy (Rust) Neon kart racing on a track that rewrites itself every lap.	Your game next Open this folder in VS Code, open Claude Code and type Start. START_HERE.md walks you through it.

Quick start

1. Install the basics

2. Get the kit: download this repo (Code > Download ZIP, then unzip) or git clone it.

3. Make your game project (run from the kit folder):

python scripts/new_game.py --name "My Game" --engine godot --dest ../my-game --git-init

Engines: godot, web (2D browser games: Phaser + TypeScript), web-3d (3D browser games: Three.js + TypeScript), cpp-sdl2, unreal, unity, bevy (Rust, Bevy 0.20; the first build compiles Bevy, 5 to 15 minutes), rpgmaker-mz (RPG Maker MZ plugins; an untested proof of concept, never run against MZ) (--list-engines shows them). Web projects: run python tools/dev.py setup once after scaffolding, from inside the new game folder. On macOS and Linux, type python3 wherever these steps say python if python is not found. Engines without an overlay yet, and what one would take: CHOOSING_AN_ENGINE.md. Unity and Unreal: create the project in the engine first, then add --adopt (see "Already have a project?" below). RPG Maker MZ: scaffold, then, inside the game folder, python tools/dev.py setup --from <a new MZ project>.

4. Check your setup:

cd ../my-game
python tools/dev.py doctor

It tells you exactly what is missing (engine path, test framework, ...) and where the fix is described (docs/ENGINE.md).

5. Start Claude Code in the project:

claude
/start-session

Then open docs/FIRST_HOUR.md and follow it: pitch, pillars, a tiny vertical slice, and your first playable build.

Want to see results first? See Made with the kit above; every example has its own README and HOW_IT_WAS_MADE, and examples/README.md has the details.

What you get in every project

• One command contract, the same on every engine: python tools/dev.py check | test | smoke | build | run | clean | doctor. Claude runs these instead of guessing flags, and a change is not done until check and test pass.
• A lean CLAUDE.md (project memory) plus docs Claude keeps up to date: game design doc, roadmap, handoff notes between sessions, architecture, asset log.
• 18 skills (slash commands): /start-session /end-session /new-feature /bug-hunt /stuck /playtest-report /asset-intake /gen-brief /model-pipeline /adr /gdd-sync /next-tier /perf-pass /release-check /publish-repo /triage-issues /game-ai /procgen.
• 5 subagents: code-reviewer build-doctor design-critic playtest-analyst researcher.
• 17 short SOPs: features, bugs, playtests, assets and licenses, git, releases, Claude Code hygiene, scope control, testing, performance, 3D, job plans and budgets, publishing to GitHub, game AI (enemies and NPCs), language models in games (cloud vs local small models, with a reality check on training your own), the 2D art pipeline, and procedural generation (levels made at runtime that are proven fair).
• Guardrails: permission rules that block reading secrets and ask before destructive commands; a session hook that loads the handoff notes.
• Resource lists for music, SFX, art, fonts and AI tools, each with license caveats, and an evidence ledger that grades every sourced claim by how well it is backed (docs/EVIDENCE.md).
• Tools: health check, doc link checker, publish pre-flight (secrets, personal data, license), asset intake with license logging, a read-only second opinion from another AI model (second_opinion.py, Kimi Code CLI), a read-only GitHub Issues reader that fences player reports off as untrusted text (issues.py, with Bug and Feel issue forms), YouTube transcript grabber, chroma-key for AI sprites, GIF maker, a retro sound-effect synth and a chiptune renderer (text patterns to a seamlessly looping WAV), an opt-in ElevenLabs client (sound effects and music with your key, logged with your plan's license), a Fish Audio text-to-speech client (balance, voice search, lines), a WAV helper that normalizes and makes any download loop seamlessly, GIMP batch processing, Inkscape SVG export, and Blender scripts that validate models, prepare them for export (pivot, transforms, LODs) and render them into sprite sheets.

Make it yours: profiles

By default projects get neutral wording and no file footer. To add your name, a footer line on new source files, and your own working-style rules for Claude, copy profiles/default.json, fill it in, and pass it:

python scripts/new_game.py --name "My Game" --engine godot --dest ../my-game --profile profiles/mine.json

profiles/example.json shows a filled-in one. Details: profiles/README.md.

Already have a project?

Add --adopt. It never overwrites anything: a file that differs gets a <file>.gold copy next to yours (engines ignore it) so you can merge by hand. Preview with --dry-run.

• Godot: your project.godot stays; copy the [autoload] Log=... line from project.godot.gold, print BOOT_OK from your main scene, install GUT. Full steps: the "Adopting an existing project" section of the Godot flow guide.
• C++/SDL2: you get CMakeLists.txt.gold and CMakePresets.json.gold. dev.py needs presets named debug and release (binaryDir build/<preset>), the exe in build/<preset>/bin/, and a --smoke N flag that prints BOOT_OK. Easiest path: merge the presets, keep your CMakeLists.
• Unreal: adopt writes docs, dev.py and .gitattributes (check LFS before the next commit). Set UE_ROOT.
• Unity: adopt writes docs, dev.py, test assemblies and a build script. Set UNITY_EDITOR.
• RPG Maker MZ: a plain scaffold into a new folder (no --adopt), then move your MZ project into its game/ folder
  (the editor's Deployment then exports the game, not the kit (verify)). Name your own plugins in OWN_PLUGINS at the top of the game's dev.py.
• Always: merge your old CLAUDE.md with CLAUDE.md.gold. The kit's one imports docs/HANDOFF.md and docs/ENGINE.md.

Kit updated since you scaffolded? Run the same command with --upgrade: it replaces kit files you never edited (tracked by content hashes in .game-kit.json), writes .gold copies only where you changed something, and leaves out kit files you deleted.

Putting your game on GitHub

Run /publish-repo in the project. It follows docs/sop/SOP-13-publish-to-github.md: pick a license (code and assets can differ), check that every asset may be redistributed, scan for secrets and personal data (tools/publish_check.py), create the repo private, lock it down (branch ruleset, secret scanning, two-factor), and only then make it public.

How the kit is laid out

core/                     copied into every game
  CLAUDE.md               lean project memory (imports docs/HANDOFF.md and docs/ENGINE.md)
  .claude/                settings.json, skills/, agents/, SessionStart hook config
  docs/                   FIRST_HOUR, GDD, ARCHITECTURE, ROADMAP, HANDOFF, STYLE, BRIEFS, CONCEPTS, VERTICAL_SLICE, ASSET_LOG
                          RESOURCES (index) + resources/, EVIDENCE (ledger) + evidence/ (raw notes), sop/, adr/
  tools/                  doctor.py, check_links.py, publish_check.py, yt_transcript.py, art/chroma_key.py,
                          blender/validate_asset.py, hooks/session_context.py (each with its exam where testable)
engines/<id>/             engine.json, ENGINE.md, FLOW.md, gitignore.append, settings.patch.json, skeleton/
engines/_template/        copy this to add GameMaker, Roblox, Love2D, etc.
profiles/                 author, footer and working-style presets for new_game.py --profile
scripts/new_game.py       the scaffolder (new, --adopt, --upgrade, --dry-run)
scripts/codename.py       a random placeholder name for a new game (Project_Cobalt_Wyvern)
examples/                 games made with the kit, each with HOW_IT_WAS_MADE.md (all rights reserved, free to reference)
media/gallery/            the README's example thumbnails (one frame of each example's GIF)
CHOOSING_AN_ENGINE.md     which overlay to pick
CHANGELOG.md              what changed and why
DISTILL_PROMPT.md, DISTILL_GOAL.txt, DISTILL_REPORT.md   how the kit's evidence was cleaned up (the report is a 10-19 snapshot)
PROCGEN_PROMPT.md, PROCGEN_GOAL.txt                      the brief and /goal line that built /procgen and SOP-17

What was tested and what was not

Being straight about it, because it matters for trust. Everything below was run on Windows 11 unless noted.

Everything known to be broken, flaky or never tried, kit and examples, is listed in KNOWN_ISSUES.md.
Items marked (verify) in the docs are the places most likely to need a tweak on first use. DISTILL_REPORT.md is a snapshot of the unverified claims from before the example games; the table above is current.

Extending the kit

• New engine: copy engines/_template, follow its README. No scaffolder changes needed.
• New skill: core/.claude/skills/<name>/SKILL.md. New subagent: core/.claude/agents/<name>.md.
• Your favorite resources: add them to the matching file in core/docs/resources/.
• New video or source worth keeping: summarize it in core/docs/evidence/video-notes.md, add an E## row to core/docs/EVIDENCE.md, and change a SOP only if the finding reaches grade B.
• Placeholders in any text file: {{GAME_NAME}} {{GAME_SLUG}} {{ENGINE}} {{ENGINE_LABEL}} {{DATE}} {{AUTHOR}}, plus the profile lines described in profiles/README.md.

Known limits

• 3D and animation: Claude scripts and automates (Blender, pipelines). Art quality still needs a human eye. See core/docs/sop/SOP-11-3d-pipeline.md.
• Licenses and store policies in core/docs/resources/ were written from general knowledge, not live-checked. The per-asset page is the source of truth.
• Most video-derived tips are grade C (one creator). SOP rules come from grade A or B findings or this kit's own tests; every tip carries its source ID so you can judge it.
• Claude Code changes fast. If a setting or command in the kit stops working, /doctor in Claude Code and the Claude Code docs win over this kit.

License

The kit is MIT, see LICENSE. Projects you make with the kit are yours: the kit adds no license or credit line to them unless your profile sets one.

The example games in examples/ are the exception: copyright er2oneousbit, all rights reserved, but free to read, run, study, link and reference (examples/LICENSE.md). The kit files inside them stay MIT. The art is CC0, but most of the audio is non-commercial (ElevenLabs free plan) or carries a generator's terms: see each example's credits and examples/LICENSE.md.