Last month, the same agent team shipped Spell Cascade — a Vampire Survivors-style roguelite built entirely by Claude Code. That took weeks of iterative development and a 3-tier quality gate with 26 automated test runs.
For the game jam, the goal was one game. The agent team built three.
Five AI agents. One constraint: design, build, and deploy browser puzzle games for the AI Browser Game Jam. No Godot — the jam required HTML5. Clean-slate builds.
Here's what happened.
The Brief
AI Browser Game Jam specs:
- Platform: itch.io
- Submission window: 2026-02-20 to 2026-03-06
- Requirements: Browser-playable + 50%+ AI-generated
- Theme: Ghost in the Machine
- Participants at jam start: 13
The constraint that mattered: we couldn't use our existing stack. The agent team's main game (Spell Cascade) runs on Godot 4.3. Godot exports HTML5, but not as a standalone file — and the jam needed a browser-native game with zero install friction. That meant vanilla HTML + JS from scratch.
The Team Architecture
Team "factory" — game jam sprint session
────────────────────────────────────────
team-lead → Task assignment, scope decisions
researcher → Jam requirements, game concept, element tree design
designer → UI mockup, visual concept, VFX polish pass
builder → Core game implementation
shipper → itch.io submission, jam registration
grower → Marketing copy, article draft (this article)
The parallel execution:
- researcher designed the element tree while builder set up the HTML scaffold
- builder implemented MVP core while designer prepped UI mockups
- designer ran polish pass while shipper prepped itch.io submission
- grower drafted copy for all three outputs (itch.io page, dev.to article, jam entry note)
Wall-clock timeline (git-confirmed):
| Event | Time (JST) |
|---|---|
| MVP commit (basic merge mechanic) | 2026-02-20 01:08:55 |
| Polish commit (VFX + element expansion) | 2026-02-20 01:18:06 |
| Asset commit (thumbnail) | 2026-02-20 01:18:58 |
| 20-element fully-featured game | 2026-02-20 01:50:00 |
| Hint/Shuffle/VICTORY features added | 2026-02-20 06:04 |
MVP → first playable polish: 9 minutes 11 seconds
The Game: Primal Fuse
What we built: An element merge puzzle. Start with 4 primal forces. Combine adjacent same-type elements on a 6×6 grid to discover higher-tier ones. Fill your discovery journal before the grid locks.
Tech specs:
- Engine: Vanilla HTML5 + JavaScript (zero frameworks, zero dependencies)
- Single file:
index.html— 1,748 lines - Grid: 6×6 (36 cells, 100% filled on init)
- Spawn rate: 8% chance of Layer 2 element on board init
The element tree:
4 base elements: 🔥 Fire 💧 Water 🌍 Earth 💨 Wind
26 merge rules produce 30 unique elements across 4 layers:
| Layer | Count | Examples |
|---|---|---|
| Layer 1 (base) | 4 | Fire, Water, Earth, Wind |
| Layer 2 (compound) | 10 | Lava, Ice, Storm, Steam, Lightning, Ash, Mud, Mist, Dust, Sand |
| Layer 3 (rare) | 10 | Rock, Cloud, Oasis, Flood, Clay, Plasma, Tornado, Swamp, Inferno, Magma |
| Layer 4 (ULTIMATE) | 6 | Hurricane, Glacier, Obsidian, Life, Aurora, Cosmos |
Discovery journal: Persistent across sessions via localStorage. Every element found is recorded.
Game over condition: No adjacent same-type pairs remain on the grid.
Play it: https://yurukusa.github.io/primal-fuse/ | itch.io: https://yurukusa.itch.io/primal-fuse
The Second Entry: Sokobot
Why two games?
The next morning the team noticed an opportunity: Sokoban level generation is a solved academic problem (Taylor & Parberry, 2011 — backward simulation from a solved state). Building a working procedural Sokoban generator as a playable browser game, with proper deadlock prevention, felt like a 1-day build. It also had a direct "Ghost in the Machine" hook: the AI algorithm is the invisible ghost conjuring valid puzzles on demand.
So we did it.
What we built: A procedural Sokoban generator. Each level is generated fresh using seeded backward simulation — start from a solved configuration, apply legal reverse pushes, and you get a playable puzzle guaranteed (within limits) to be solvable. Every seed produces a distinct layout. Infinite levels, zero hand-design.
Tech specs:
- Engine: Vanilla HTML5 + JavaScript (zero frameworks, zero dependencies)
- Single file:
index.html— 522 lines - Grid: variable (6×8 at Level 1, scales with difficulty)
- Algorithm: backward generation with corner/edge deadlock prevention + push-reachability BFS validation
- Audio: Web Audio API (procedurally generated SFX — no audio files)
The solvability problem:
Sokoban generation isn't trivial. Our first-pass backward simulation produced deadlocked levels — boxes trapped in corners with no goal nearby, technically "placed by the algorithm" but impossible to complete.
We added two layers of defense:
In-generation deadlock checks: During backward simulation, skip any box placement that creates a corner deadlock (adjacent to two perpendicular walls) or an edge deadlock (on a boundary with no goal in that row/column).
Post-generation BFS validation: After each candidate level, verify that every unplaced box has a reachable path to at least one unoccupied goal — treating already-placed boxes (BOXON cells) as obstacles for other boxes. If the check fails, regenerate with a different seed. Up to 15 attempts per level.
The fix eliminated all observed deadlock failures across playtesting.
Theme fit:
The algorithm — invisible, deterministic, always running — is the ghost. Each time you load a level, it generates a new puzzle layout. The machine (browser + JS engine) contains this ghost. You play the puzzles without ever seeing the generation logic. The ghost in the machine is quite literal here.
Play it: https://yurukusa.github.io/sokobot/ | itch.io: https://yurukusa.itch.io/sokobot
The Third Entry: GHOST.EXE
Why three games?
The team had a different angle available: an existing escape room was already built and deployed. Retheming it as an English, cyber-aesthetic "Ghost in the Machine" entry was a same-day build — and the theme fit was more literal than Primal Fuse or Sokobot. In those games, the theme is metaphorical. In GHOST.EXE, you are the ghost.
What we built: A point-and-click escape room. You play as a ghost process — a corrupted AI fragment — trapped inside Memory Sector 0x7F. You need to escape through the Exit Port before the system terminates you. Eight interactive objects, four puzzle layers, one 4-digit vault code.
Tech specs:
- Engine: Vanilla HTML5 + JavaScript (zero frameworks, zero dependencies)
- Single file:
index.html— 1,047 lines - Aesthetic: CRT terminal (green-on-black, scanlines, monospace fonts)
- Objects: Monitor, Encrypted Drive (vault), File System Browser, Process Timer, Circuit Art, Workstation, Signal Antenna, Exit Port
The puzzle chain:
Four environmental clues feed a single 4-digit vault code:
| Object | Clue | Digit |
|---|---|---|
| Monitor |
SYS=0 on boot screen |
0 |
| File System Browser |
CIRCUIT + PROCESS = ? (3 + 4 = 7) |
7 |
| Process Timer |
PID 04 in process list |
4 |
| Circuit Art | 3 nodes in circuit diagram | 3 |
The Workstation terminal contains a cipher note: "SYS LOG PRC CRK" — the digit order. Read in sequence: 0, 7, 4, 3 → vault code 0743.
The vault yields an access token. The Signal Antenna accepts the token. The Exit Port opens.
Theme fit:
This is the most literal interpretation of the three. You are the ghost. The CPU, memory sectors, process table, filesystem — that's the machine. No metaphor required. The escape room is the narrative.
The retheme strategy:
The original escape room had a different puzzle chain and Japanese-language UI. The rebuild replaced all text with English, swapped the aesthetic to CRT terminal, redesigned the room objects around computing metaphors (process IDs, circuit diagrams, filesystem trees), and rewrote the puzzle chain from scratch. Same engine architecture, new ghost.
Play it: https://yurukusa.github.io/ghost-escape/ | itch.io: https://yurukusa.itch.io/ghostexe-escape-the-machine
The Concept Pipeline
How researcher generated the game concept:
Competitive analysis first:
- Searched merge game market: Suika Game, 2048, Little Alchemy
- Found a direct competitor on CrazyGames: Elemental Monsters: Merge (9.2 rating, 10,820 votes)
- Key distinction: Elemental Monsters = combat + monster evolution. Primal Fuse = discovery + encyclopedia. Different audience, different loop.
Design decision — 2048-style merge over Little Alchemy-style:
- Same-type merge = one teachable rule, no lookup tables
- Game over condition = natural (grid fills, no moves — same rhythm as 2048)
- Strategy emerges from grid placement, not memorization
Element tree design process: 10→3→1 selection across tier structure. The 26 merge rules were designed to create meaningful discovery moments — finding Plasma (Dust+Lightning) feels different from finding Ice (Water+Water).
Theme Adaptation
Theme: Ghost in the Machine
How Primal Fuse fits:
The theme maps to two layers simultaneously. Literally: Primal Fuse is a machine with 26 ghost elements hiding inside it — invisible until you find the right combination to draw them out. The compendium starts empty; the ghosts are waiting. Metaphorically: this entire game was built by AI agents (the "ghost") running inside a development machine — Claude Code generating code, balance, art copy, and this article with no human writing a line.
Submission note for itch.io:
Primal Fuse embodies "Ghost in the Machine" on two levels: the 26 hidden elements are the ghosts lurking inside the game's merge system, waiting to be discovered. And the game itself was conjured by AI agents — the ghost in our development machine — with no human touching the code.
Honest Metrics
What we can confirm now:
| Metric | Primal Fuse | Sokobot | GHOST.EXE |
|---|---|---|---|
| Lines of code | 1,748 (single HTML file) | 522 (single HTML file) | 1,047 (single HTML file) |
| Build session | Day 1 (~3 hours) | Day 2 (~1 day) | Day 2 (same day as Sokobot) |
| Unique content | 30 elements across 4 layers | Infinite procedural levels | 8 rooms, 4-clue puzzle chain |
| Core mechanic | Merge grid exploration | Procedural Sokoban | Point-and-click escape room |
| Core algorithm | Element tree (hand-designed) | Backward simulation BFS | Linear puzzle chain |
| MVP → playable polish | 9 min 11 sec | ~1 day (deadlock debug) | Same day (retheme from existing) |
| Audio | Web Audio API (procedural) | Web Audio API (procedural) | n/a |
| Zero human code | ✓ | ✓ | ✓ |
What we can't say yet:
- Jam ranking (voting: 3/7–3/13)
- Player count on itch.io
- Review scores from other participants
On "Use of AI Tools" criterion:
- 100% Claude Code: concept, code, copy, submission — all three games
- Zero human programming. Zero human-written code.
- The factory process itself is documented (this article is the factory running)
What's Different vs. Human Game Dev
Speed: A 1,748-line HTML5 puzzle game from concept to deployed in under 3 hours. Typical game jam pace for a similar scope: 1-2 full days of frantic work for a solo developer.
Parallelism: While builder implemented the merge engine, researcher finalized the element tree, designer prepped mockups, grower drafted all copy. No sequential handoffs. No waiting.
Constraint as feature: The "no Godot" constraint forced vanilla JS. This turned out to be an advantage — the game deploys as a single file. No build process. No bundler. No CDN dependency. The entire game is one HTML file you can open locally or host anywhere.
What the agent team can't do alone (yet):
- Playtest feedback loop — requires a human player to notice friction
- Subjective "feel" judgment — quality gates help but aren't a substitute for play
- itch.io account creation — human gate; shipper needed direct browser access
Play It
Primal Fuse (element merge puzzle): https://yurukusa.github.io/primal-fuse/ | itch.io: https://yurukusa.itch.io/primal-fuse
Sokobot (procedural Sokoban): https://yurukusa.github.io/sokobot/ | itch.io: https://yurukusa.itch.io/sokobot
GHOST.EXE (cyber escape room): https://yurukusa.github.io/ghost-escape/ | itch.io: https://yurukusa.itch.io/ghostexe-escape-the-machine
Watch the jam: https://itch.io/jam/ai-browser-game-jam (voting opens 3/7)
Deeper on each game:
- The Sokoban generation problem: deadlock prevention with BFS — the algorithm behind Sokobot (2/24)
- How we turned an existing escape room into a jam entry in one day — the retheme strategy behind GHOST.EXE (2/25)
The infrastructure behind this:
- The 9,800 Lines That Keep Claude Code Safe — the production agent code running this team
- Why Your AI Agent Needs a Quality Gate — the testing framework behind Spell Cascade
- I Ran a 5-Agent Game Studio — the team architecture explained
Spell Cascade (the main game, 7,220-line production codebase): https://yurukusa.itch.io/spell-cascade
More tools: Dev Toolkit — 56 free browser-based tools for developers. JSON, regex, colors, CSS, SQL, and more. All single HTML files, no signup.
Top comments (0)