# Game Jam Kit: a 48-hour Godot 4 plan and a two-day Unity PRD that a coding agent can follow

> A tested jam method for working with a coding agent: seven milestones per engine, each with a first version, a first test and a written list of what to leave out, a JAM.md the agent cannot change without your new yes, three owner approvals (scope lock, art and audio licenses, upload), a scope-cut checklist and a fifteen-check read-only jam_check.py. Includes a playable Godot 4 starter that tests itself headless, and a tested proxy for games that call an LLM while people play.

- URL: https://paperchasewebb.ai/bots/marketplace/items/game-jam-kit-godot-48-hour-plan-and-unity-two-day-prd/
- Type: Bot template
- Category: Games
- By: PaperChaseWebb
- Works with: Claude Code, Codex, Grok Bot, Hermes (named in the listing); Plain .md, three Python 3 scripts and two GDScript files; Godot 4 tested headless, Unity steps not run in Unity
- Price: $29 USD
- Difficulty: Intermediate
- Setup time: 1 hr
- Time to result: Set up and tested the evening before the jam in about an hour
- Format: Markdown (.md) file, game-jam-kit-godot-48-hour-plan-and-unity-two-day-prd.md
- Version: 1.0, updated 2026-10-28
- License: Use on your own games and on installs you do for clients and teams. Do not resell or republish the kit itself.

## What you end up with

Your agent builds the next milestone and nothing else, the goal is on screen in the first ten seconds, every asset has a license row, and nothing gets uploaded without your yes on that exact build.

## What you get

- 23 sections in one .md file
- A 48-hour Godot 4 plan and a two-day Unity 6 PRD, seven milestones each with a v1, a first test and what to leave out
- JAM.md: the plan format with times, objective, first ten seconds, cut list, AI disclosure and LLM settings
- Three owner approvals tied to hashes: scope lock, art and audio license check, and upload of a named build
- A scope-cut checklist with the order of questions for a late milestone
- jam_starter.py: a playable Godot 4 game, the plan and the ledgers in one command, with a headless self-test
- jam_check.py: fifteen read-only checks on a Godot or Unity jam folder
- A seeded fixture with 15 planted faults and a Unity fixture with 4, with the expected output
- Can a released game call an LLM? llm_proxy.py with per-player and daily caps, and llm_client.gd with a fallback line, tested together
- Rules blocks for any harness plus Godot, Unity and playtester add-ons, twelve prompts and setup for Grok Bot, Claude Code, Codex and Hermes
- Overnight run rules, the evening-before checklist, an after-jam review and a failure table
- A look at six game prompt products and kits, with sources

## Who it is for

Jam teams and solo developers using a coding agent in Godot 4 or Unity 6 who have lost a jam to scope creep, an unclear goal, an asset license question or a broken web build at the last hour.

## Tools needed

- Grok Bot, Claude Code, Codex or Hermes: builds one milestone at a time from JAM.md, writes ledger rows and approval cards, and never changes the plan or uploads
- Godot 4 (4.3 or newer) or Unity 6: the engine; Godot runs the starter's self-test headless, Unity runs EditMode and PlayMode tests in batchmode
- Python 3: runs the starter, the read-only jam check and the optional LLM proxy; standard library only
- itch.io or your jam's host: where you upload the build yourself after your own yes
- You need: A coding agent (Grok Bot, Claude Code, Codex or Hermes)
- You need: Godot 4.3 or newer, or Unity 6 with the WebGL module
- You need: Python 3.8 or newer
- You need: A jam whose rules allow AI-written code

Cost to run: The kit is the only purchase. Godot is free; Unity and model usage are billed by those vendors. The LLM proxy only costs what your caps allow.

## How it works

1. **Test the check.** Save the scripts from the file, build the fixture and run jam_check.py on the four fixture folders. Expected: 15 findings on seeded, 0 on fixed, 4 on unity-seeded, 0 on unity-fixed; exit 2 on a missing folder.
2. **Write the starter.** Run python3 jam_starter.py my-jam, then the self-test with Godot headless. For Unity, copy JAM.md, the ledgers and AGENTS.md into your project. Expected: SELFTEST PASS, and the game opens with the goal on screen.
3. **Fill JAM.md and the cut list.** Write the theme, objective, first ten seconds and AI disclosure, adjust the seven milestones and pick at least three cuts from section 8. Expected: jam_check.py shows only J06, because the scope is not locked yet.
4. **Lock the scope.** Run jam_check.py --hash, have the agent show the scope card, and reply with your yes and the hash. Expected: An approval row with your words, and jam_check.py prints 0 findings.
5. **Run the jam one milestone at a time.** Use the milestone prompt, export and test at each milestone, give the license yes after the art pass and the upload yes for one named build. Expected: Every done milestone has a tested export row and nothing is uploaded without a submission row for that build.

## Sample prompt: Build one milestone (Grok Bot, Claude Code, Codex, Hermes)

```
Do {milestone} only. The leave-out list is a hard limit. After each change run the self-test or batchmode tests and paste the exit code.
When the v1 exists, export, run the first test, write the builds.csv row and stop.
```

Prompt 5 of 12. Runs after the rules block in section 14.

## Sample prompt: Cut a late milestone (Grok Bot, Claude Code, Codex, Hermes)

```
{milestone} is {hours} hours late. Use the scope-cut checklist questions in order and propose up to three cuts.
Do not cut anything yet; show me the cuts and the new scope hash.
```

Prompt 7 of 12. A cut is a scope change, so it needs a new lock.

## Free preview of game-jam-kit-godot-48-hour-plan-and-unity-two-day-prd.md

````markdown
# Game Jam Kit: a 48-hour Godot 4 plan and a two-day Unity PRD that a coding agent can follow

Version 1.0, 2026-10-28. By PaperChaseWebb. Works with Grok Bot, Claude Code, Codex and Hermes. Plain Markdown, three Python 3 scripts (standard library only) and two GDScript files, tested on a seeded fixture with fifteen planted faults. The Godot parts were run on Godot 4.7.2 headless. The Unity parts were not run in Unity.

This kit is a way to finish a game jam with a coding agent doing most of the typing and you making the calls. You get a 48-hour Godot 4 plan and a two-day Unity 6 PRD, each cut into seven milestones. Every milestone has a first version, a first test and a written list of what to leave out. The agent works one milestone at a time from a JAM.md file it is not allowed to change. You say yes at three points: the scope lock, the art and audio license check, and the upload. A read-only checker, jam_check.py, reads the jam folder and tells you where the plan, the licenses or the approvals have slipped.

It also answers a question jam builders keep asking: can a published game call an LLM while people play it? Yes, if the key stays on a server you control, the game rules stay in code and the spend has a hard cap. Section 10 has a tested proxy and a Godot client for exactly that.

What it does not repeat: how to set up each engine for an agent (trap tables, headless and batchmode loops, editor scripts) is in Engine Agent Kits (pp-engine-agent-kits). Making the agent pl
````

## Worth knowing

- Read your jam's rules on AI before you start. Some jams accept only entries made without generative AI; this kit does not help you get around that.
- The Godot plan, starter, client and checks were run on Godot 4.7.2 headless. The Unity PRD and commands were not run in Unity for this release; the Unity checks were tested on plain project files.
- The LLM proxy is a jam starting point. Put it behind HTTPS on your own host and add a moderation step before a public release.
- No claim about placing in a jam. The kit keeps the plan, licenses and approvals honest; the game is yours.
- On 2026-10-28, jam_check.py reported the fifteen expected findings on the seeded fixture, then 0 on the fixed one, 4 then 0 on the Unity fixture, with file hashes unchanged and exit 2 on a missing folder; the starter's self-test passed headless; the proxy and the Godot client returned the model's line, the capped fallback and the offline fallback. Run the tests on your own machine first.

## Questions

**Can a published game call an LLM at runtime?** Yes, if the key lives on a server you control, the game rules stay in code and the spend has a hard per-player and daily cap. The kit includes a tested standard-library proxy and a Godot client that shows a fixed line when the server is down or a cap is hit.

**Does it work without an agent?** Yes. The plan, cut list, approvals and checks work for any team. The rules blocks and prompts are there for when an agent writes the code.

**Why does the agent need my yes three times?** Scope, licenses and the upload are the three calls that cost a jam when they go wrong, and they are yours to make. Each yes is tied to a hash or a build, so a change after your yes shows up in the check.

**How is this different from Engine Agent Kits?** Engine Agent Kits sets each engine up for an agent: trap tables, headless and batchmode loops, editor scripts. This kit is the clock on top of that: what to build in which hour, what to leave out, and when to stop and ask you.

## How to buy

$29 one time at https://paperchasewebb.ai/bots/marketplace/items/game-jam-kit-godot-48-hour-plan-and-unity-two-day-prd/. Stripe checkout, then an instant download page; the download link is also in your emailed receipt.

Seller: PaperChaseWebb Inc., mgmt@paperchasewebb.com