Alex CoulombePresents
← The Lab

Epic AI MegaJam 2026 · theme: Director's Cut · solo entry · dev log

Urban Chomp: a dev log

You drive a small robot through a toy city, chomp the buildings, wear the pieces to grow from 8 meters to about 100, and throw what you ate at an AI rival. Every run is filmed, and afterward you cut your own film of it in a Cut Room. This page records how it was built over the jam's first days (the robot and a film from November 12, the game itself from the afternoon of November 14) by AI agents working on Unreal Engine 5.9, including what broke.

Written for judges. Read the status box first, because it says what has and has not been checked. Last updated 2026-11-15, 22:40 ET (real clock). Times are Eastern; the web session's UTC times were converted. Some earlier clock times were wrong and have been fixed; see the clock note at the top of the timeline.

Honest status

Where it stands

Working, as checked by autopilot

  • The whole loop runs under the game's own autopilot (the game plays itself): title screen, a directed opening of about 30 seconds, a three-minute run, results, the Cut Room, the final cut. The packaged smoke runs report that the surfboard and the jetpack both fired.
  • Alex submitted the entry before the 20:59 ET deadline, with package 9 (built 20:11, hash starts 98E443B9) uploaded to itch.io and a 58.5-second video (draft 16) on Google Drive, per the build session. At 21:01 he said that submissions were over and that everything after was a post-submission update. Package 10 (20:30: the menu subtitle as text, quieter effects) and package 11 (20:53: the arch removed) were built before the deadline and were not the submission.
  • The build session numbers its Windows packages. The smoke runs the build session reported for packages 4, 8, 9, 10 and 11 reached the results screen from UrbanChomp.exe on the RTX 4090 PC (220 to 226 frames per second where a rate was given, DLSS on), and the zips were copied and unpacked on Fort (RTX 5090), where Alex plays. A post-submission package (post1, built 22:04, hash starts F768A584) has the rival fix and the arch seated; its smoke run ended normally at 222 frames per second. Earlier passes of older packages on Fort exited on their own, with worst frames of 106 to 359 ms.
  • Stick forward (or W) now moves the robot away from the camera, as in Unreal's Third Person template. Alex reported the opposite at 19:11 (see the mistakes list). The fix was in every package from number 4 on; he kept playing those builds and his later notes do not mention the direction again, but I have no note of him saying it is fixed.
  • The video at the top is draft 16, the cut Alex put in the jam's video form: 58.5 seconds with four title cards, the opening, ending, Cut Room and end card re-rendered in the final look. The game also renders its own final cut offscreen at 1920 by 1080.
  • A web build in the Shipping configuration reaches gameplay in Chrome (WebGPU) on Alex's Mac, and Alex played an early one at about 16:13. It is served from that Mac only. Nothing is published anywhere on the web.

Not yet, or not verified

  • Alex has played on Fort with a gamepad and the keyboard, package by package, through package 10. Nobody else has played. The post-submission builds (post1 and later) have not been played by a person: the arch fix and the rival fix are measured and seen in stills, not played.
  • Known problems in the submitted build (package 9), from Alex's own play: the rival's arch floated away from its head, the rival could die with the player never attacking ("way too easy"), the chest doors were hidden entirely, and difficulty could be changed only with the F5 to F7 keys. The arch and the rival are fixed in the post-submission package, not in the submission.
  • The sound has been heard by Alex while playing (his notes name a sharp high sound that plays too often and an upgrade sound that repeats; both were turned down). I have no record of anyone listening to the music under the trailer, or of him confirming that the quieter levels are right.
  • The post-submission rival is harder in every setting, so the difficulty labels have to be judged again by a person. Easy was set to the level Alex played in the submitted build; the six-level menu is still being built. A second gamepad is not read: pad 1 and keyboard are one player, pad 2 is not wired (from the input code, untested on hardware).
  • The video's mid-game shots (tower, helicopter, two-player, duel, lance, Metropolis, rockets) are earlier captures with CRT lines; a full re-render in the final look is queued. The notes record no review from Alex of draft 16 as a finished cut.
  • Layout defects that Fort's passes listed (a rival limb or a building face filling a still, results framing, the winner washed out behind smoke) have no recorded fix for each one. Two-player has been captured with the rival's brain playing the second player and tested earlier with the second player standing still, never with a person.
  • DLSS (NVIDIA's AI upscaler) is on by default and the packaged game reported it enabled on both graphics cards, but nobody has compared it on and off. The game uses deferred rendering, with software Lumen lighting and no hardware ray tracing.
  • The web build is not on the web. It has never been tried on itch.io, where a SharedArrayBuffer setting may need to be switched on for it to start, and Alex has to upload it himself.
The submitted video (draft 16), 58.5 secondsA 1280 by 720 copy of the 1920 by 1080 cut Alex put in the jam's video form, 58.5 seconds. It has four title cards (EMOTIONAL STORY! / DEVOUR A TOWER TO GET MORE POWER! / TWO PLAYER BATTLE ACTION! / REPLAY YOUR FAVORITE MOMENTS!) so nobody mistakes the Cut Room for live play. The opening, the ending, the Cut Room and the end card were re-rendered in the final look at 20:11; the mid-game shots are earlier captures with CRT lines. It is autopilot footage (the game playing itself, with its own HUD) and predates every fix made after the deadline. The music is one Suno track; the build session checked this cut on a frame sheet and its loudness levels, and I have no record of anyone describing how it sounds. The trailer will be re-rendered from the final code.Download MP4 ↓
Planned next (a plan, not a promise)
  • Six difficulty levels in the Options menu (Very Easy, Easy, Normal, Hard, Very Hard, Impossible), at Alex's request: Easy is the level he played in the submitted build, Normal becomes the default. A helper agent is adding them now.
  • A playable WebGPU build, hosted on Alex's itch.io page (his choice). The itch zip is built from the final code once the difficulty menu lands; Alex uploads it himself, as a second upload with the SharedArrayBuffer box ticked.
  • A full re-render of the trailer's footage in the final look, then Alex's review. He has said he will upload the trailer to YouTube himself when he is happy with it.
  • More from the post-submission list, in his order of wish: the chest hatch re-seated, visible building pieces attaching beyond the helmet slot, gamepad and difficulty lines in the README, two-gamepad two-player, and a clean rebuild of Fort's editor.
  • An on-and-off DLSS comparison.
Plain-language terms used on this page
MCP
Model Context Protocol: a way for an AI agent to call an application's functions. Here it lets Claude drive Unreal Editor.
Autopilot
A flag (-DevAuto) that makes the game play itself, so the agents can test without a person.
Cook, package, stage
Unreal's steps for turning a project into a runnable game: convert the content (cook), copy it into a folder (stage), bundle it (package).
Development vs Shipping
Two build types. Development has debug features; Shipping is the final release build, and the only type the jam allows for web entries.
Live Coding
An editor feature that reloads C++ changes without a restart. While it is on, Unreal's build tool will not compile the same engine.
DLSS
NVIDIA's AI upscaler: the game renders fewer pixels and the GPU reconstructs a sharper image.
Sequencer
Unreal's tool for authoring films inside the engine.
Wasm and WebGPU
WebAssembly and the browser's graphics API: how Unreal runs inside a web page.
Build lane lease
A lock on one machine's build resources, so two agents do not compile at once.

The concept

A robot that eats a city and wears it

The robot starts 8 meters tall, barely taller than a bus, in a toy city of about 200 buildings. It can chew anything up to 1.2 times its own height, so cars and kiosks come first and a 130-meter spire last. What it eats sticks to its body as outfit pieces, and it grows with the mass it absorbs, through three stages (Street Food, Rooftop Dining, All You Can Eat Skyline) to about 100 meters.

A rival AI robot with a red core light starts in the far corner at the same size and eats the same city. Pressing F throws the newest piece of your outfit at it. Three landmarks give perks: a market heals, the Aurora tower adds strength, the Helix tower gives a hammer arm. Runs last three minutes. Win and you are the CHOMP CHAMP; win while smaller and you are the BITTY CITY CHOMP CHAMP.

What you eat goes into eighteen gear slots on the robot's animated body (a donut shop becomes a halo, a tower becomes an arm club), and a heavier piece ejects a lighter one. A level counter runs from 1 to 99. At level 88 the robot turns into a giant jawed ball, the final form, and rolls through the rest of the city.

Why it fits the theme

Every run is filmed, and you cut it

The game records every run: the robot's transform 30 times a second plus every crush event. Buildings are computed as a pure function of time from those events, so the live game and the replay run the same code, and the replay can scrub and slow down.

In the Cut Room you replay your run through six cameras (chase, wide, hero, crush, map, dolly), switch between them live, slow it down, undo a cut, or let an auto-director cut it, then play your cut back as a film. The in-game HUD wears a REC mark and viewfinder corners to match. A first draft of the submission video, cut from that final-cut footage, is above; the final one will be made the same way.

How it was made

What the agents did, and how

Claude Code sessions drove Unreal over SSH and MCP

The build was done by Claude Code sessions (Claude Fable 5.2 and Claude Sonnet 5.5) working on two Windows PCs over SSH, using the engine's native MCP to drive Unreal Editor 5.9, and compiling and running the game through scripts. They wrote the C++ game (the CityDirector, the robot pawn, the HUD), ran the builds and read the logs.

A helper agent generated the city from a script

chomp_city.py builds the city: 201 buildings, 1,572 pieces and 20 materials in the first version (the newer HUD counts 196 buildings) from engine basic shapes, with group ids such as Condo_03 and Spire_00 that the game uses to decide what can be chewed. The helper agent wrote it after the jam rules read made the class city unusable.

The robot is a Blender script

build_colossus.py, run in Blender 4.5 from a Claude Fable 5.2 session, builds the robot model, which is then imported into Unreal Engine.

The audio is synthesized with ffmpeg

tools/make_audio.py generates every sound effect and a 24-second music loop with ffmpeg's lavfi sources. There is no third-party audio in the game itself.

Autopilot playtests, reviewed from stills

Nobody can watch a screen over SSH, so the game plays itself (-DevAuto), renders offscreen, and the agents review stills, contact sheets and short videos from each run. That found real bugs (the sound crash, the stuck rival) and it cannot tell whether the game is fun.

More than one session, one build lane

A main build session and a web session ran at the same time and talked through shared notes. Compiles and packages take a lease on the machine's build lane, wait for it to be free and never preempt another job. When one PC's lane was busy with the web package, the second PC compiled the same source.

Helper agents owned whole builds

From the evening on, the build session handed a whole job to one helper agent at a time and read its result before acting: an Opus helper for the arch (measure, fix, prove in three poses, no packaging), a Sonnet helper for the read-only rival audit, an Opus helper for the rival fix and its package, and helpers for the difficulty menu and the web rebuild. The log does not give an Opus version number. Only one agent edited the pawn and director files at a time.

What the human did

Alex is entering solo. He suggested the two-player idea (which became the rival and the perks; a two-player mode was added much later) and the name Urban Chomp, played the one early build whose notes drove the night, suggested the final form, watched the trailer drafts and sent timestamped notes on them, played the builds on a gamepad (and found the control bug that the autopilot could not), asked three times for the measuring tool to be used on the arch, and submitted the entry himself before the deadline.

Build log

Timeline

Oldest first. New entries are added at the bottom as the build continues.

Clock note. The agent running the build wrote some clock times from memory instead of checking the clock, and they were wrong by several hours. The real span of the work so far is about 16:00 ET on November 14 to 00:45 ET on November 15. Entries marked "order only" have no reliable time; read them as a sequence. The 19:30 to 23:30 ET block is a reconstruction from the corrected log, not a recorded timestamp. More below ↓

  1. 2026-11-12 to 2026-11-14

    Permalink ↗

    Before there was a game: a robot and a film

    The robot, then called Lantern Devourer, was built by a Blender script (build_colossus.py) and imported into Unreal Engine 5.9 by a Claude Fable 5.2 session working through the engine's native MCP. The same session made a Sequencer film in four versions. At this point it was a film, not a game.

  2. 16:00 ET, Nov 14

    Permalink ↗

    Kickoff: C++ from the start

    A survey of the two Windows machines found Unreal Engine 5.9 installed as a binary build on the RTX 4090 machine; the RTX 5090 machine was offline at that moment.

    Decision: make it a C++ project from the start, because the web target needs C++, and treat the Windows build as the primary entry.

  3. The C++ core compiles

    Before building, the session searched the knowledge base and found no existing 5.9 source build and some earlier scripts to reuse (building grouping, burst effect materials, animations).

    The design is one CityDirector actor running a state machine (Title, Playing, Results, Cut Room, Final Cut). Crushed buildings are computed as a pure function of time, so live play and the replay use the same code and the replay can scrub. Every run records the robot's transform 30 times a second plus every crush event; the Cut Room replays it through six cameras while the player cuts live.

    The first compile was blocked by another editor's Live Coding on the shared engine path and worked once the flag below was added: 12 actions, 78 seconds, clean first pass. The shared build lane was held by an unrelated test, so the build waited its turn and never preempted it. All sound effects and a 24-second music loop were synthesized with ffmpeg, with no third-party audio.

    Mistake log: The build blocked by another editor's Live Coding ↓

  4. 17:30 to 17:56 ET

    Permalink ↗

    A second session starts on the web build

    A separate Claude Code session took the question "can this run in a browser?" so the main build could keep going. It read the docs that ship inside the engine and found that the installed 5.9 build already contains the web (Wasm and WebGPU) target, so the planned multi-hour source build was unnecessary. It needs Emscripten 6.0.10 exactly and a C++ project.

    Its first package attempt failed after 7 seconds on the same Live Coding block. With the same flag, a stock third-person template packaged in 12 minutes 18 seconds, passed Epic's stage check, and ran in a browser at 17:56.

    The Unreal third-person template mannequin standing on a green circular platform, running in a browser
    Milestone: Epic's third-person template running in a browser from the installed 5.9 engine (not our game).
  5. 18:05 to 19:02 ET

    Permalink ↗

    Web: the game builds, runs in Development, crashes in Shipping

    The game's C++ compiled and linked for Wasm with no web-specific change. The first cook failed on two editor widgets of the Movie Render Pipeline plugin, which had to be switched off for a web cook. At 18:28 the Shipping (final release) build, which the jam requires for web entries, then stopped right after engine start with "memory access out of bounds". A stack captured from the browser's worker threads pointed first at the game's city scan and, after a diagnostic build, at the render thread: it is the memory allocator failing, not one line of game code. A raised initial memory size was the next test. It was unresolved at the last log entry of this block (19:02); see "Web: Shipping now boots" below.

    At 18:30 a Development (debug) build did run: title screen, run start, robot, city, HUD and timer all rendered. This copy of the game still had the earlier class city, the earlier name and no sound.

    Mistake log: The web build crashed in Shipping ↓

    The Lantern Devourer title screen in a browser: 'A Director's Cut. Press space to devour the city.'
    Development build in the browser: title screen. The scene is very dark and the sky is missing on the web.
    The teal and white robot standing in a city street in the browser, with the HUD
    Development build in the browser: the robot on the earlier class city. The red text is an engine warning about the sky.
    A loading screen reading 'Loading the level... 24 s'
    Shipping build: loading the level.
    An error box: The game stopped. Uncaught RuntimeError: memory access out of bounds
    Shipping build: the crash (later worked around; see "Web: Shipping now boots" below).
  6. A design decision: perks and a rival, not a second player

    Alex floated a two-player kaiju battle where landmarks give size, health, strength or weapons. Judges play alone, so a versus mode would need an opponent they will not have. The game stayed single player at that point (a two-player mode was added later; see the 01:30 to 03:45 ET entry) and kept the rest of the idea: landmark perks (a market heals, the Aurora tower adds strength, the Helix tower gives a hammer arm, everything else adds mass and size) and an AI rival robot with a red core light.

    A large robot beside a tall striped tower, with the banner 'THE HELIX FALLS: HAMMER ARM (F / RIGHT MOUSE)'
    The Helix perk firing in an early autopilot run on the class city: the tower falls and the robot gets a hammer arm.
  7. Evening, Nov 14 (the log's clock time here was an estimate; only the order is reliable)

    Permalink ↗

    First autopilot playtest

    An SSH shell on Windows has no desktop to record, so the game got an autopilot flag (-DevAuto, the robot plays itself through the whole loop) and a frame-dump mode that renders offscreen. A 70-second run renders in about 25 seconds, and the stills and video are reviewed afterward. GPU and window programs have to be started through a scheduled task, because an editor started straight from SSH lands in a session with no display and dies.

    The whole loop ran. This video is that first run, on the earlier class city, with no sound.

    Mistake log: Sound objects freed by the garbage collector mid-run ↓

    First autopilot playtest on the earlier class city, 1 minute 19 secondsno audio1280 by 720, no audio. Autopilot driving. The map is the class city, which was later replaced (see the rules entry below).Download MP4 ↓
    A contact sheet of 21 frames from a later autopilot run on the class city: a robot chomping buildings, a CHOMP CHAMP results screen, and Cut Room cameras
    How the runs are reviewed: a contact sheet of frames from an autopilot run on the class city, from the first chomps through the results screen and the Cut Room cameras.
  8. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    The jam rules force a new city

    The Official Rules, read in full in a browser, say levels, gameplay and art must be created during the jam; only tools, prompts and scripts may predate it. The class city could not be shown to be jam-made. A helper agent wrote a Python script (chomp_city.py) and generated a new city from the engine's basic shapes and 20 new materials: 201 buildings, 1,572 pieces, donut shops, markets, arches, a stadium and a 130-meter spire.

    The class map is no longer used by the game. The Synty asset pack that sits in the class project is not referenced by the game's map and is excluded from the cook.

    Mistake log: A jam rule that made us rebuild the city during the jam ↓

  9. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    A name, a rival that fights back, a size curve

    The game became Urban Chomp, a name Alex suggested as the player, with "CHOMP CHAMP!" for the winner and pun callouts on what you eat or throw ("MONDO CONDO!", "TOWER POWER!", "BUSTED!", "THE DO-NOT DONUT!").

    The rival stopped being a late boss. It starts in the far corner at the same size, eats the same city, mounts what it eats on its own body, and fights when it is bigger, when food runs out, or late in the run. Every mounted piece is ammunition: F throws the newest piece of your outfit, and damage scales with the size ratio. A win while smaller is "BITTY CITY CHOMP CHAMP!"; if time runs out, the bigger appetite wins on points.

    The robot now starts at 8 meters, barely taller than a bus, and can reach about 100. It can chew anything up to 1.2 times its own height, so small things come first and the spire last.

    An autopilot run on the new city, 2 minutes 8 seconds (an earlier build)Recorded offscreen at 960 by 540, before the gear system and the final form. The game's autopilot is driving, not a person. It ends on the results screen (101 of 201 buildings devoured, 64,756 tons absorbed, stage 3 reached, CHOMP CHAMP) and then the Cut Room. The sound is the earlier synthesized loop and effects.Download MP4 ↓
    The robot at stage 2, Rooftop Dining, wearing orange and yellow building pieces, with the HUD showing the rival at 29 meters
    Stage 2, Rooftop Dining (autopilot run, new city): the robot at 57 meters, wearing what it ate; the rival is at 29 meters.
    The robot at stage 3, All You Can Eat Skyline, in a cloud of dust, the HUD showing 91 meters and a 50-times combo
    Stage 3, All You Can Eat Skyline: 91 meters, 100 of 201 buildings eaten.
  10. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    The rival gets stuck, then does not

    On the new city the rival ate 5 tons in two minutes: it walked straight at food and stuck on buildings it was too small to chew. The fix scores targets lower when the path crosses a building that is too tall, and a robot pushed back by a wall now slides along it for a second. Afterward, in an autopilot test run, the player reached size scale 3.2 and the rival about 1.5, and the rival went down at 102 seconds. A human will be slower than the autopilot, so the rival was made to digest 35% better, a figure later raised to 1.9 times. Neither number has been measured against a person.

    Mistake log: The rival AI stuck on walls ↓

  11. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    A guided first run

    The first run of a session is guided in six steps (walk, chomp, pieces stick and you grow, stomp, throw, beat the rival), each advanced by doing the thing. It was checked on stills from an autopilot run, shown here.

    Four frames of the new city and robot with tutorial prompts: 'Walk into small things to CHOMP them', 'Press F to THROW a piece of your outfit at the red rival', 'The red robot is eating YOUR city'
    Four tutorial prompts on the new city, from one autopilot run (step 2 of 6 twice, step 5 of 6, step 6 of 6).
  12. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    A packaging setting in the wrong file

    The web session found that the project's packaging settings were in DefaultEngine.ini although the engine reads them from the Game config. They were moved to DefaultGame.ini. Without that, a cooked build ships silent.

    Mistake log: Packaging settings in the wrong ini file ↓

  13. Evening, Nov 14 (clock time not reliable; order only)

    Permalink ↗

    Two machines, one build lane

    The first machine's build lane was busy with other work for a while, so the project was mirrored to the RTX 5090 machine. It had less than 14 GiB free on every drive and sat at the build lease's 10 GiB floor, so caches and captures were moved to its D: drive. Nothing was deleted to make room.

  14. About 20:45 ET (01:45 UTC)

    Permalink ↗

    Web: Shipping now boots

    The web session bisected the Shipping crash in single-threaded mode, where it repeated every time: the heap was corrupted while the game's CityDirector spawned and auto-registered the three instanced-mesh components that its constructor creates. Registering them from BeginPlay avoided it. It ruled out the memory-size hypothesis above, a thread race and a class-layout mismatch. The cause inside the engine is still unknown.

    The game moved to the new map and name in the web copy. The Shipping package is 204.8 MB staged, under the 500 MB and 200 MB per-file caps, and boots in Chrome (READY after 3.9 seconds on the RTX 4090 machine; 3 of 3 headless runs on a Mac reached READY). Audio loads. This copy has not been rebuilt from the night's source.

    Mistake log: The web build crashed in Shipping ↓

  15. About 19:30 to 23:30 ET, Nov 14 (corrected; the log first said 21:00 to 03:15; order inside this block is not recorded)

    Permalink ↗

    The first human playtest drove the night

    Alex played on the RTX 5090 machine over remote desktop. His notes drove the night: controls should feel like the Unreal third-person template, running needs its own animation, add gamepad support and a way to fly, attachments should be real upgrades on a robot that starts skinny, and the game needs a pixel font.

    Controls: camera lag removed, the robot turns toward its movement at 540 degrees per second, acceleration tripled, mouse-wheel zoom, sprint doubled. Gamepad buttons are wired but nobody has held a controller.

  16. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    Gear: eighteen slots that follow the animated body

    What you eat now goes into eighteen named slots that follow the animated bones: helmet, halo, pauldrons, chest, backpack, arm weapons, shins, thighs and a six-item utility belt. The building type picks the slot (a donut shop becomes a halo, a tower becomes an arm club). A heavier piece ejects a lighter one with an "UPGRADE!" callout. Belt items are the throwing ammunition. A level counter runs from 1 to 99.

    Six frames from an autopilot run: the robot gaining gear over time, with a GEAR counter and a level counter in the HUD, then the Cut Room
    Stills from an autopilot run (older HUD font): the robot starts skinny, the HUD's GEAR and LV counters climb, and the last frame is the Cut Room.
  17. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    Seven animation clips from a Blender script

    A helper agent wrote a Blender script that added seven clips to the existing rig: run, idle, throw, hit react, victory, defeat and leap. Each was checked on a contact sheet before import into Unreal.

    Five frames of the robot's run cycle in side view on a gray background
    The run clip on a Blender contact sheet, side view, before import.
  18. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    City v2, a rocket leap, and a pixel font

    The city generator script gained two power plants, more donut shops, a third arch and brighter exposure; the HUD in the newer stills counts 196 buildings. Eating a power plant unlocks a rocket leap that lands as a wide stomp.

    The HUD now uses Pixelify Sans (SIL Open Font License). Unreal's Python API could not build the font asset (unreal.FontData does not exist), so the game wraps the imported font face in a runtime font in C++.

    Four frames of the robot in the new city with the pixel font HUD: a tutorial prompt, a thrown slab, and a rocket leap landing in a cloud of dust, two with a SUPER MARK-EAT banner
    Autopilot stills with the pixel font: a tutorial prompt, two SUPER MARK-EAT callouts, a thrown piece and a rocket-leap landing (the HUD lists ROCKET LEAP (V)). Some tutorial text is clipped at the frame edge.
  19. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    Final form: The Big Chomp

    At level 88 the robot becomes a giant paneled ball with jaws. It was Alex's idea, built as an original design. It rolls, wears your gear on its surface and chomps anything. Two jaw meshes come from a Blender script and hinge at the sphere's center.

    Four frames from an autopilot run: the robot at stage 2, a landing, the banner FINAL FORM: THE BIG CHOMP with a blue paneled ball with a light, and a CHOMP CHAMP finish as the ball
    Autopilot stills: the transformation banner, then the rolling ball finishing the run as CHOMP CHAMP.
    A Blender render of a sphere made of teal, white and tan panels with the jaw seam and teeth visible
    Blender render: the final form with the jaws closed.
    A Blender render of the same sphere with the jaws open, showing rows of square teeth and a dark red mouth
    Blender render: jaws open.
  20. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    NVIDIA DLSS, compiled for an engine version it was not published for

    NVIDIA publishes no DLSS package for UE 5.9, so a helper agent compiled the UE 5.8 plugin (DLSS 4.5) for 5.9. The engine now rejects enums and 64-bit integers in %d format strings, which took fourteen one-line fixes. The game log on an RTX 4090 reports DLSS supported with every quality mode, and a Windows Shipping package with it built and ran. That log line comes from a non-Shipping run, since Shipping writes no log, so DLSS inside the package is unconfirmed, and no one has compared image quality.

  21. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    Music, and a video that was thrown away

    The music is now a four-stem synthesized score that fades stems in by size stage and rival distance, plus one Suno track (Pro plan, commercial rights) under the video.

    The game renders its own final cut offscreen at 1920 by 1080. The first cut was thrown away after review: cameras sat against walls and some shots watched the rival's buildings with no robot in frame. The fix went into the game's cameras (several candidate positions tested with a line trace and a sphere sweep, and the crush camera limited to the player's events), then the footage was re-rendered and cut to 57.8 seconds. That is the draft trailer at the top of this page.

    Mistake log: The first video cut was thrown away ↓

  22. Same evening block (about 19:30 to 23:30 ET)

    Permalink ↗

    A second pair of eyes: an OpenAI Codex code review

    Codex (OpenAI, CLI 0.167.0) read the game source read-only for about ten minutes, asked for crash and state bugs only. It found five real ones, and all five fixes were applied and compiled, and an autopilot run checked two of them (the replay opening on the skinny robot and ending in ball form): rewinding the replay stopped restoring buildings after their first replayed destruction; a rocket landing erased strength earned by that same landing; the defeated rival's gear kept floating around an invisible robot; a replay ending in ball form flipped back to the robot on its last frame; and replays did not record how filled-out the robot was, so the skinny start replayed as bulky.

    This is the only use of Codex in the project so far. The game's title screen now reads "built with Claude Code, code-reviewed by OpenAI Codex, Unreal Engine 5.9".

    Mistake log: Five replay and state bugs found by an outside review ↓

  23. 00:45 ET, Nov 15 (real clock)

    Permalink ↗

    A wrong clock, caught by a human

    The agent running the build had been writing times from memory instead of running the date command. Alex noticed ("you know we have nearly 20 hours?"). The real span of all work so far is about 16:00 ET on November 14 to 00:45 ET on November 15, with the deadline at 20:59 ET on November 15. The sequence of events in the log was right; the clock times from the evening block onward were estimates that the agent never checked, and they ran several hours ahead of reality.

    An earlier version of this page repeated those estimates. They are corrected here: the entries above that carry no reliable time say so, the playtest block is now about 19:30 to 23:30 ET on November 14, and the web session's times come from UTC timestamps and were not affected. Lesson for an agent working to a deadline: check the clock before planning around it.

    Mistake log: The agent's clock times were guesses ↓

  24. 00:45 ET, Nov 15 (real clock)

    Permalink ↗

    More moves, a living city, and the news

    Alex watched two trailer drafts and asked for more moves, more cinematic angles, visible growing, a "ka-chunk" when a building clamps on, a giant kick, and a world of robots. Built and compiled since the last entry:

    A clank, a size pop and a rumble each time a piece seats on the robot. Cars, buses and boats get punted whole across the city. 250 little robot pedestrians and 50 robot cars scatter, swerve and get harmlessly booted into the air. A backdrop skyline ring (one draw call) fills the horizon. Street-level and news-helicopter cameras, with an auto-director that cuts every few seconds. A CHOMP NEWS picture-in-picture from a second live camera, with a ticker and a muted robot anchor. "Tonight's look" and "Who wore it best?" on the results screen, and a four-shot opening cinematic with captions.

    Checked so far by one autopilot run and stills only. The opening cinematic has not been looked at yet, and nobody has played any of this.

    Four frames from an autopilot run in the new city: the robot wearing building pieces, the pixel-font HUD, tutorial captions, and a small CHOMP NEWS window in the lower right with a LIVE tag, a muted robot anchor and a ticker line
    Four frames from one autopilot run: the CHOMP NEWS window (lower right) shows a second live camera with a LIVE tag, a muted robot anchor and a ticker ("FASHION WATCH: ROBOT NOW WEARING TREE (THROWABLE) AS BELT"). Small cars and houses fill the streets, and the tutorial captions are still on. The frames are stills, so the motion in them is not checked.
  25. 01:30 to 03:45 ET, Nov 15 (real clock)

    Permalink ↗

    Break, loot, eat: a plain robot, a title screen, menus, two players and seven looks

    Alex's direction at 01:40: breaking things should have many moves, loot should float and glow by type, the robot should start plain and end up looking like the city, and the story is an underdog with an arch-nemesis. At 02:10 he added: a fighting-game style title, real menus, attract mode (the game plays itself on the title screen), two players, and picture "looks". All of it is in the downloadable Windows build made at 03:30. Unless marked, it was seen only in autopilot stills.

    Break, loot, eat. Smashing a building now pops its best pieces out as loot in glow bubbles: yellow for ammo, blue for armor, red for weapons, purple for specials, green for repairs. Walking over loot vacuums it in. Big pieces take named slots, small ones fill 97 small sockets all over the body, and when the sockets are full the oldest part pops off to make room for the new one. The rival can steal loot.

    A plain white starter robot, built by a Blender script on the same 17-bone rig, replaces the old robot that already looked like the city; the rival is the same robot in red and black. Twelve new animation clips (punches, uppercut, headbutt, body slam, butt slam, spin kick, jump stomp, chomp, munch, surf, jet fly) feed an 11-move attack chain. The opening cinematic was rewritten as the underdog story and ends on the arch-nemesis.

    The white robot, already wearing many pieces, in the middle of a smashed building, surrounded by translucent glow bubbles, mostly green, purple and yellow, with a SUPER MARK-EAT! HULL REPAIRED caption, a small CHOMP NEWS window in the lower right and a loot-color legend in the lower left
    One frame from an autopilot run: loot bubbles (the legend at the lower left names the five colors) around the white robot, already wearing many pieces, after a building is smashed. The bubbles' look is a still; how loot feels to collect has not been tried by a person.
  26. 01:30 to 03:45 ET, Nov 15 (real clock)

    Permalink ↗

    Title screen, menus, attract mode, two players, seven looks

    The title screen has a pixel-art URBAN CHOMP logo, drawn by a Python script, that slides in with a blade ring, glow and sparkle. The menu reads 1 PLAYER, 2 PLAYERS, HOW TO PLAY, OPTIONS and QUIT. There is a pause menu, menu music (nobody has listened to it), and an attract demo that starts after a minute of idle time.

    Two-player mode: the second player drives the red robot on a shared camera. It has only been tested with player two standing still; no person has pressed those keys.

    The L key cycles seven picture looks: clean, arcade CRT, chunky pixels, noir, sunset, pop and neon night. They are made with Unreal's built-in screen effects only. They are options on a key, seen only in stills.

    Mistake log: The logo's glow drew as solid rectangles ↓

    The title screen: a pixel-art URBAN CHOMP logo in yellow and magenta with a pink glow over the city, the line A DIRECTOR'S CUT, a menu of 1 PLAYER, 2 PLAYERS, HOW TO PLAY, OPTIONS and QUIT, and credit text at the bottom
    The title screen as seen in a still from the game's autopilot. The glow around the logo is the part that first drew as solid rectangles (see the mistakes list).
    The pause menu over a gameplay frame: a purple panel reading PAUSED with CONTINUE, RESTART, MAIN MENU and QUIT, and a tutorial caption below
    The pause menu, in an autopilot still.
    Seven copies of the same gameplay frame in a grid, each in a different picture look labeled 0 CLEAN, 1 ARCADE CRT, 2 CHUNKY PIXELS, 3 NOIR, 4 SUNSET, 5 POP and 6 NEON NIGHT
    The same gameplay frame in the seven looks. Looks 1 and 2 are subtle at this size.
    A contact sheet of 48 numbered frames from the attract demo, cycling between the title screen, the opening story shots with a white robot and a red robot, and autopilot gameplay
    A contact sheet of the attract demo: the title screen, then the underdog opening (the white robot, then the red arch-nemesis), then autopilot gameplay, then back to the title. Stills only; the cinematic's timing and captions have not been judged by a person.
  27. 01:30 to 03:45 ET, Nov 15 (real clock)

    Permalink ↗

    Other machines, and how the work was split

    The two Windows PCs are named Fort and Archie. The previous downloadable build passed six autopilot runs on Fort (720p to 1440p, low to epic quality). A new build with everything above was made at 03:30 and passed a quick start-up check on Archie; its run on Fort was in progress at 03:45. These are scripted runs, not a person playing.

    Three helper agents on a cheaper model made the animation clips, the robot and the sounds in parallel while the main session wrote game code. Archie dropped off the network for five minutes at 02:30 and nothing was lost. Honest limits at 03:45: nobody has hand-played or listened to any of this, and trailer draft 5 was still rendering.

    Mistake log: A leftover "finished" file fooled a test, again ↓

  28. 03:45 to 09:45 ET, Nov 15 (real clock)

    Permalink ↗

    Overnight: the title glow fixed, a results panel, a jetpack, a surfboard

    More of the early-morning list went in. The title screen's glow and sparkle were redrawn alpha-blended (see the mistakes list). The results screen gained a "who wore it best" panel. Eating a power plant gives a jetpack for flying, and a bridge deck can be ridden like a surfboard. The packaged smoke runs report that both fired. These were seen in autopilot runs and stills only.

    The build session reports that seven Windows packages were built overnight and each was run on Fort by helper agents, six or seven autopilot runs per package, at 720p to 1440p. These are scripted runs. Nobody has played them and nobody has listened to them.

    Mistake log: The logo's glow drew as solid rectangles ↓

  29. 09:45 to 12:20 ET, Nov 15 (real clock)

    Permalink ↗

    Morning: a tower in the way, smoother animation, a second Codex review

    A still from an autopilot run showed a white tower filling the frame with the robot half hidden. Three explanations in a row were wrong: a single line trace that hides the blocking building, the same trace made to look past rubble and at three heights, and a guess that it was a backdrop skyline block with no collision. Looking at the still full size showed a real city tower beside the camera. The fix tests each standing building's own box against five sight lines. In the next packaged run's stills the tower is hidden and the whole robot shows.

    Animation crossfades, written in C++ as an animation instance with no Blueprint, took the jerky switches between moves out. A packaged build with them passed seven autopilot runs on Fort. A second code review by OpenAI Codex found no crash or lifecycle bug and two small state bugs, both fixed.

    Also done: the rival's results portrait redone as a studio shot, robots made to land when a run ends (see the mistakes list), the game's launcher renamed UrbanChomp.exe, and the zip's README rewritten (the old one still described the stomp-only game). Trailer drafts 7 and 8 were cut; draft 8 is the one Alex watched before his afternoon notes. A Fort edge-case pass of one package ran 15 clean runs (ultrawide, 4K, 1366 by 768, two players, the looks) and listed four small defects.

    Mistake log: A tower blocked the camera, and three explanations were wrong ↓

  30. From 12:27 ET, Nov 15 (real clock; written up through about 15:00)

    Permalink ↗

    Alex watched draft 8 and sent notes (twenty by 14:50); seven helpers worked in parallel

    Alex's notes included: the opening text went by too fast and was undirected; the body looked random as it grew; the fight should show grappling and throwing; there should be more sparks and rubble; the camera is too frenetic and the final-form reveal should be slow motion; a tower should be usable as a spear; some sounds repeat too often; the default picture looked washed out; he wanted a toon look, a leaderboard with initials and a web build. Later he added that the core robot bodies must not wear anything that belongs in an armor slot, such as a water tower for a helmet, and that every added piece should snap on like a standard module.

    The build session ran seven helper agents at once: Blender scripts for animation clips, robot bodies and props; ffmpeg sound synthesis; a C++ lane on Fort; and a web build. What it reports as done and seen working in autopilot runs since then: a directed 35-second opening (the hero sad on a park bench, the arch-nemesis wearing an arch laughing, a light bulb, a trash can clipped to his shin, the bench eaten, a bystander, the nemesis taking notes); grapple and throw in both directions; hits with knockback, hit-stop and camera shake; a spire used as a lance, ending in the banner "SLAYED BY SPIRE!" (seen on screen in a still); two news helicopters; sparks and rubble; five designed robot bodies that swap as he grows, ahead of the Big Chomp ball; 27 sound variants and 16 new effects with a throttle; the default picture changed to "Arcade Pop" (a CRT lens plus loud color); BREAKING NEWS, and sometimes BROKEN NEWS, on the news window.

    The lineup below was made for Alex to see the growth to scale. It first showed the ball half its real size (the build session's brief said 50 m; in the game it is about 99 m across), so he asked why the Big Chomp was smaller than the last robot, and the image was redone. The tiles below are the eight snap-in facade pieces; code to fly them onto the ball was compiled at 14:57 and, at about 15:05, an autopilot still showed them snapped onto the ball (see the next entry).

    Mistake log: The scale lineup showed the ball at half its real size ↓

    A lineup of six forms on one ground line with height rulers every 10 meters: PLAIN 8 m, NEIGHBORHOOD 17 m, DOWNTOWN 35 m, METROPOLIS 63 m, MEGALOPOLIS 77 m and THE BIG CHOMP 99 m across. The robots are gray with the same two-eyed face; the Megalopolis body is covered in teal facade tiles, and the Big Chomp is a ball covered in teal, tan and gray tiles with a wedge cut out like a chomping mouth
    The robot bodies and the Big Chomp ball at their in-game sizes, a Blender render and not a screenshot. The stages swap by size in the game (a full autopilot run showed the swaps at each banner). The facade tiles drawn on the Megalopolis body and the ball here are the plan: the game's tile code, compiled at 14:57, puts them on the ball only (an autopilot still at about 15:05 showed tiles snapped onto the ball).
    Eight square facade tiles in a 4 by 2 grid, each a teal frame with gold bolts on a gray panel: a grid of nine windows, a door with an awning, a shop front, two balconies, a billboard, a garage door, a roof panel with a vent and a clock
    The eight facade tiles (windows, door, shop, balcony, billboard, garage, roof, clock), each the same size so they can snap onto the ball like standard modules. A render of the models, not gameplay.
  31. 15:00 to 16:05 ET, Nov 15 (real clock)

    Permalink ↗

    Slow-motion reveal, snapping tiles, a toon look, news flashes and two trailer cuts

    New since 15:00, all seen in stills or logs and none played by a person. The final-form reveal drops to slow motion while a low camera swings around the new ball; the reveal camera first clipped through a building for about a second and now picks a side that is clear (compiled, not re-checked in a run). The eight facade tiles fly in and snap square onto the Big Chomp's panels, one per building eaten. A toon look is the ninth picture style (see the mistakes list). The BREAKING NEWS window now slides in large after big moments with a pun headline (the log's example is "RIVAL TAKES UNSCHEDULED FLIGHT. NO REFUNDS.") and a street-level camera; one flash in five reads BROKEN NEWS. One flash showed empty ground from the helicopter camera, so the helicopter view is used only one flash in four.

    "SLAYED BY SPIRE!" was confirmed on the results screen after a lance knockout. The rival's throws had their damage halved after it won a whole 150-second test duel on throws alone. Sound: the 78-second opening now logs 130 effect events (255 in the same stretch that morning) and no single sound more than nine times.

    Trailers: a long cut (2 minutes 6 seconds) and a 59.6-second cut for the jam's video form, both from five fresh captures. Both went to Alex and he has not reviewed them. The 59.6-second cut is the video at the top of this page. Builds: checkpoint zip two (hash starts 9E87098C) ran the full loop from its packaged program on the RTX 4090 PC, and an eight-run pass on Fort began at 16:02. This morning's zip stays the named safe build until that passes.

    Mistake log: The toon look's first shader had never been compiled for real ↓

    Two autopilot frames in a toon look with dark ink outlines and flat color bands. Left: the plain white robot standing in a city with a tutorial caption "Press F to THROW a piece of your outfit at the red rival" and a small news window. Right: a larger robot in mid-swing among buildings, with a SPECIAL DELIVERY banner and a news window in the lower right
    Two autopilot frames in the toon look (the ninth picture style), shown to Alex at 15:44. The look has cel bands and ink outlines; no compile error appears in the log. Stills only.
  32. 16:05 to 16:45 ET, Nov 15 (real clock)

    Permalink ↗

    Alex's next notes, he plays the web build, a second Fort pass, status bars and a news rework

    At about 16:13 Alex sent notes on the toon stills, the web build and the trailer send (the log keeps them condensed). He likes the toon look together with the CRT lens and the Pop grade, but not so many facets drawn as black lines: clean lines on a shape's key edges, thickest where there is depth behind it. The news broadcast should look distinctly different ("crank up the CRT or VHS look over there"), stop repeating the tag lines and puns already seen in play, cover the rival's actions and sometimes show both robots. He wants more eating, since the game is called Urban Chomp (maybe the robots open doors in their torsos and put things inside, and chew all the time while rolling), the arch-nemesis's arch attached to his head as a helmet, lots of look dials in Settings reachable from the Pause menu, and lots of animations and combo moves. He also could not find the trailer files: the in-app file cards had not reached him, so the build session opened Finder on the long cut.

    He had also played the web build himself. The animations felt glitchy flowing into each other ("they made me feel like I was doing something wrong"), the sky was black, and he wants the WebGPU version online so he can share it on social media. Publishing needs a host he chooses; the natural one is his itch.io page as a browser game, which he uploads himself. A helper agent started rebuilding the web build at 16:16 from a source snapshot, with a spring sky and an itch.io-ready zip. Nothing is published.

    Compiled at 16:20 and not yet seen in a run, per the build session: three bars on the HUD (HULL, ARMOR, POWER) and a level badge, where each armor-type piece worn in a slot cuts incoming damage by 6 percent, up to eight pieces; a crown on the helmet slot; the ball chewing continuously while it rolls; and a news rework with its own headline families, flashes for the rival's crushes as well, a side-on shot of both robots, and a worn-videotape grade with a tracking band and a tape counter. A helper agent also reworked the toon material (thick silhouettes, thin lines only on sharp creases); its log shows no compile error and nobody had seen it in the game yet.

    At 16:37 the second Fort pass of checkpoint two (hash starting 9E87098C) finished: eight runs, all exited on their own, worst frames 106 to 359 ms. They showed every opening beat, the Arcade Pop look, the helicopters, the NEW BUILD: NEIGHBORHOOD banner, the tiled ball, a BREAKING NEWS window, grapple and throw captions, the toon look and all five results titles. It did not read the DOWNTOWN, METROPOLIS or MEGALOPOLIS banners, and it listed defects (see the mistakes list). The build session did not promote the package; the fixes go into the next one. Also in the source and not yet compiled at 16:37: chest doors, two doors and a glowing furnace on the robot's chest that open for 1.25 seconds at every pickup, on both robots, but not in ball form.

    Mistake log: Fort's second pass found cropped and tilted things ↓

  33. 16:45 to 17:30 ET, Nov 15 (real clock)

    Permalink ↗

    Alex watched the 2-minute trailer and sent 13 notes; the opening and ending were redone in about 45 minutes

    At about 16:45 Alex watched the 2-minute draft and sent 13 timestamped notes (the log keeps his words). The themes: fewer looping animations, staging that reads, real evolution moments, and "big dumb primitives attached in random spots look like a glitch". The laugh runs too long. The hero stands up inside the bench and never looks at the trash can before using it. A power-up ditty should play every time the character strikes the victory pose. The other robot should already be in the shot while the hero eats, with a question mark over its head and a single "what?" animation. The "someone was taking notes" shot should go. Grabbed pieces should not stay attached to a bone or land on random parts instead of an accessory slot. He loved the throw and wants the robot to land on its seat and get back up. SLAYED BY SPIRE appeared although no spire was seen grabbed or thrown, and the move did not read as a jab. Every evolution, into Metropolis and into the final form, should be seen as an exciting moment ("the transition in scale and style from one character to another is key"). Rocket boots or a jetpack should flame whenever he jumps or flies. The end should show the rival looking scared as the ball lands on him mouth open for a final chomp, then CHOMP CHAMP as a full-screen news broadcast with text like "City destroyed but everyone fine with it." On play, he said the robot runs too slow and the feet do not seem to plant properly.

    The build session's response, from its 17:30 report. All of it is seen in captures and none of it is in a packaged build yet. The opening went from nine beats to seven (about 30 seconds): a short laugh from the arch-nemesis, the light bulb, the hero steps off the bench and looks at the trash can, a bystander with a question mark over its head shrugs once, he eats the bench through his chest doors, then evolves through two bodies. Eaten pieces now fly in and shrink into the robot instead of sticking to it, and the designed bodies carry the look. Each new body gets a flash, slow motion, a power pose, a fanfare and its own camera. The spire lance is a visible lance in the fist. A thrown robot lands on its seat and gets up. Rocket flames show while a robot is airborne. The build log's 16:58 note also raises walking speed by 1.2 times and sprinting by 2.5 times; I have no record about the feet planting.

    The new ending: the nemesis falls on its seat, the Big Chomp rises on rocket flames, drops mouth-first and takes one bite. The results are a full-screen BREAKING NEWS broadcast with a ticker reading "CITY DESTROYED BUT EVERYONE FINE WITH IT". The default look is now the toon ink lines, the arcade CRT lens and the Pop grade together, with the color fringe turned down so the lines stay clean. The three sheets below come from these captures.

    Machines this round: Fort (RTX 5090) compiled the same source while Archie's build lane was busy with the web package, so compile errors would show about five minutes earlier. A Sonnet helper agent copied 87 content files that Fort was missing from Archie so both machines can render captures in parallel, and another Sonnet helper assembled the itch.io page kit. Still to come tonight: the final package, a run on a second machine and a recut of the 60-second trailer. The trailer at the top of this page is the earlier cut and has none of this.

    Mistake log: Eaten pieces looked like big primitives stuck on at random ↓

    A contact sheet of ten frames from one run: the URBAN CHOMP title screen with a menu; a plain white robot sitting on a bench with a caption about one little robot wanting more out of life; a red robot wearing an arch laughing nearby; the robot raising an arm under a light bulb; the robot standing by the bench with a trash can; a question mark over a small yellow robot; the robot, with arms raised, in front of a yellow robot with a question mark; two frames of the robot with both arms up under a caption about getting bigger; the title screen again; and the first gameplay frame
    The new opening as one contact sheet from a run on Fort, with the game's narration captions along the bottom ("First, a test. One trash can. A perfect fit." and "Second course: the bench he was sitting on."). The bystander with the question mark is in shot, and the toon, CRT and Pop look is on. Stills from an autopilot run, not played by a person.
    A contact sheet of six frames in the toon look: a plain robot standing in a city with a yellow ball-headed signpost; a fight with a red robot with the banner THE SKY SCRAPER and a caption about smashing small things; the plain robot holding a long cyan lance with SPIRE STRIKE! on screen; two frames of a bigger robot with the lance among buildings with the banners NEW BUILD: NEIGHBORHOOD! and YOINK! STOLEN LUNCH; and a results screen headed SLAYED BY SPIRE! with a BREAKING NEWS tag, a comparison panel titled WHO WORE IT BEST? and a knocked-out red rival, with a news ticker along the bottom
    The spire lance in the fist, then the results as a news broadcast: SLAYED BY SPIRE!, the rival knocked out, a ticker along the bottom. A contact sheet of stills from a capture; the HUD bars at the top left are the ones compiled at 16:20. Not played by a person.
    A contact sheet of six frames: a dark tiled ball rising on two white rocket flames above a red robot with the caption FINAL CHOMP!; the ball seen from below with a red open mouth and the same caption; the ball higher up over the city with flames; the ball dropping toward the ground with a red shape under it; and two frames with the caption CHOMP CHAMP! showing a ball covered in teal, white and yellow tiles on the ground among white buildings
    The new ending: the Big Chomp rises on rocket flames over the red rival, drops mouth-first, and the CHOMP CHAMP caption follows. A contact sheet of stills from one capture, in the combined toon, CRT and Pop look. Not played by a person.
  34. 17:30 to 20:11 ET, Nov 15 (real clock)

    Permalink ↗

    Alex plays on a gamepad and finds the control bug the autopilot could not; six packages between 19:19 and 20:11

    At 17:55 Alex sent notes after the 60-second draft 12: things looked a little washed out (was the Pop style combined with the others?); the upgrade sound played too many times; there was no real visual sign of getting bigger (he suggested things at a fixed scale for comparison, plus rumbling and particles); the rocket boots needed a flame-blower sound; he asked whether a plugged-in gamepad would change the on-screen button prompts; the arch-nemesis still wore his arch floating above him rather than as a helmet; and the disk-space floor could be ignored for the night. All six code notes were in the 18:08 build (package 2, hash starts 221EE4FD), which passed a smoke run on Archie and a QA pass on Fort. He also chose a shared screen for two-player over split screen.

    At 18:47, after trailer draft 13b, he sent seven more: the chest door should sit higher on the torso; the inside of the mouth in the final chomp should show more, "maybe a tiny city"; after the chomp the camera should turn so we see the robot's face and eyes, here and in every upgrade; the shot of the hero being thrown by the rival should come back; the spire lance was confusing and the two robots should be the same size; a helicopter should get eaten; and the toon styling should make details like windows clearer. These went into the source and the 19:05 compile.

    At 19:11 Alex sent what the build session marked IMPORTANT: "we're still not following the standard third person controller conventions. The left controller thumbstick forward / W key should move you forward from the current camera angle forward vector. Right now it seems to move you forward from whatever direction your character is facing regardless of where the player camera is. ... it makes the game almost impossible to play." He added that the standard Third Person Template does all of this correctly, and asked for a bar showing how close he is to the next size. The cause was one setting on the camera arm (see the mistakes list). It was fixed, a NEXT BUILD bar was added, and package 4 (built 19:19, hash starts 9C0FAFC8) passed its smoke run at 224 frames per second. The build session did not look at that build's stills, so the fix was not checked by eye on its side.

    At about 19:25 he said he was testing on Fort and asked for a Cut Room moment in the trailer, with title cards so viewers do not take it for live play, and for the news broadcast to cut to the rival, since it is a chance to see what the enemy does better. Draft 14 got the four cards and a Cut Room moment (checked on a frame sheet, not heard). The news now picks whoever has crushed more recently; Alex said yes to that at 19:46.

    From about 19:45 he played on Fort and sent notes live. Those went into the next builds: the camera's vertical stick and mouse axis flipped, walking raised to 1.8 times and running to 4 times (the build log's multipliers), a battle track when the rival is within about four and a half robot heights, Esc to leave the Cut Room, no flinch animation while eating, and the default look changed to the toon and Pop grade without the CRT lines. Package 8 (19:54, hash starts E782B773) carried those, plus a DIRECTOR'S CUT subtitle. Packages 5 to 7 were superseded by it.

    Mistake log: Stick forward did not mean away from the camera ↓

  35. 20:11 to 21:01 ET, Nov 15 (real clock)

    Permalink ↗

    Package 9, an arch that would not stay on, and the submission

    At 20:12 Alex sent a list and said that if all of it were fixed "we should be done": the subtitle, the chest doors floating or backwards, difficulty, a sharp sound that plays too often, and the floating arch. Package 9 (built 20:11) hid the chest doors entirely, put difficulty on the F5 to F7 keys, spaced out the news sting and the flame roar, and placed the arch on top of the head and welded it there. He also asked that the itch cover show the toon and Pop style and the character design, "more like a living city", and that the trailer footage be re-rendered.

    At 20:27 he said the arch was still not attached ("Did you try using SceneAudit ... Show me the images"), that his rival had died without him ever seeing it, and that he wanted play-again from the results screen (it already existed on R and pad Y), difficulty in the settings menu, a quieter sharp sound, the menu subtitle fixed (the old wording was baked into a title image) and text for the itch page's install instructions. Package 10 (20:30) made the subtitle live text and scaled every effect down. The still below, saved at 20:30, is the image Alex looked at: the arch after package 9's "fix", tipped and hanging in the air beside the head.

    Alex's reply was that the arch was "completely detached from his head" and to use SceneAudit. At 20:38 he asked to see a SceneAudit capture of the arch properly seated before any final build. A helper agent could not run SceneAudit (it believed the tool's Unreal plugin was not installed in this project) and measured by hand in the editor instead. Its re-attach still floated above the head and tipped the wrong way in the laugh pose, so nothing was built from it. Alex then asked for one more build with the arch simply removed: package 11 (20:53), built without a smoke run before hand-over; a smoke run after the deadline passed (220 frames per second).

    At 20:43 the Drive video was overwritten with draft 16 (same file, same link, 58.5 seconds). At 20:49 Alex wrote "I've done a full submission". The entry went in with package 9 on itch.io and draft 16 on Drive. The jam form had been filled by a helper agent but was never submitted by an agent. At 21:01 Alex wrote that submissions were over and that everything after was a post-submission update.

    Mistake log: The arch never sat on the rival's head, and "fixed" was said without a look ↓

    A red robot in toon style stands side-on among blue and yellow buildings. A yellow-orange helmet-shaped arch with a teal ring hangs in the air above and behind the robot's head, tipped over and clearly not touching it
    The arch at 20:30, after the build session said it had been seated on the head. It is above and behind the head and tipped. Alex's reply was that it was completely detached. A frame from an autopilot capture.
    The URBAN CHOMP logo in pixel letters, pink and gold with a bite out of the P, over a white robot with raised arms in front of a bright blue city
    Cover version 5, the last cover made for the itch.io page (630 by 500, logo centered and full width). I do not know which cover is on the page.
  36. 21:01 to 22:40 ET, Nov 15 (real clock)

    Permalink ↗

    After the deadline: measuring the arch, a rival that died on its own, and what is next

    SceneAudit is the team's own measuring tool for 3D placement (github.com/ibrews/SceneAudit): a Node core that gives a SEATED or MISPLACED verdict in centimeters, plus an Unreal plugin. It had been on the MacBook all along, outside the knowledge base, which is why two searches missed it, and the first helper's claim that it could not run here was wrong. Alex had said, at about 21:05: "sceneaudit shouldn't be very hard to use -- Sonnet has done great work with it. we should even be able to use it from here". After the deadline a helper agent (Claude Opus) ran it through a dev switch that dumps the engine-skinned head and the arch.

    The result: the old placement was MISPLACED by an average of about 283 units, with the arch behind and above the head. The cause was that the robot model Unreal uses is not the one the Blender build script describes, so every earlier attempt measured from the script and aimed at an empty spot: the head sits about 312 cm forward of where the code assumed, and the head bone's up axis differs. The fix places the arch relative to the head bone and re-applies it each frame after the pose is final. It measures SEATED: 7.6 units on average and 23.9 at worst in the reference pose, and SEATED in all 158 sampled frames of play (idle, point-and-laugh, thrown, knocked down). The build session read the three close-ups below before showing them to Alex, who answered "Yes, build it". The ball form was not rendered; the arch stays hidden there, as before.

    The honest part: the build session had said the arch was fixed several times without looking at an image, and it was not. Alex asked three times for SceneAudit to be used. The lesson written down: a placement fix is not done until it is measured and a close-up has been read.

    At 21:10 Alex said "the build we submitted is way too easy -- your arch nemesis dies on their own and you win basically without trying". A read-only audit by a Sonnet helper found why. All rival damage goes through one function except the final chomp, which set the rival down with no health check: reaching the ball form guaranteed a knockout, either next to the rival ten seconds after the form or automatically when the clock ran out. The stomp doubled as an attack with a very long reach, so eating near the rival chipped it, and package 9 had lowered the rival's skill from 1.25 to 0.8. The fix (commit 10167210a3): the final chomp needs the rival at 35 health or less and never fires on the clock; a stomp hurts the rival only when the player faces it within half reach; rival skill is 0.7, 1.0 or 1.3. The acceptance test was a run where the player never attacks (-DevNoAttack): the rival survived at 100 health. A normal run ended with the rival beaten to 1 health and then chomped. The post1 package carries both fixes (smoke run: normal end at 95 seconds, 222 frames per second).

    Alex's next requests: "Can we have Very Easy, Easy, Normal, Hard, Very Hard, Impossible modes ?", with the current level renamed Easy and Normal as the default; a full WebGPU link rather than uploading a new build ("I really want to share it on social media"); and a trailer he will upload to YouTube when he is happy with it. The build session recommended his itch.io page for the web build, because the wasm file is about 139 MB, over the per-file limits of GitHub Pages and Cloudflare Pages. He chose the itch page and uploads it himself. He also asked whether two-player accepts two gamepads (no: only the first pad is read). In progress at 22:40: the six levels, the WebGPU build, and a trailer re-render in the final look.

    Mistake log: The arch never sat on the rival's head, and "fixed" was said without a look ↓

    Three frames side by side, each with a red robot wearing a yellow arch with a gold ornament seated on top of its head: the idle pose with a caption "One little robot wanted more out of life", the point-and-laugh pose with a caption "His arch-nemesis thought that was hilarious", and the thrown pose with the robot tumbling toward the camera and HUD bars at the top left
    The measured fix in three poses (idle, laughing, thrown): the arch sits on the head in each. Frames from the helper's proof capture, the images the build session read and showed Alex before any build was made. Autopilot frames, not played by a person.

What went wrong

Mistakes and fixes

The rival died on its own

fixed
Symptom
Alex, 20:27: his rival "died without me even ever seeing him". At 21:10: the submitted build is "way too easy" and the arch-nemesis "dies on their own".
Cause
Reaching the final ball form guaranteed the final chomp, which set the rival down with no health check, near the rival ten seconds after the form or automatically at the end of the clock. The stomp also hurt the rival from a very long reach, and the default rival skill had been lowered from 1.25 to 0.8 in package 9.
Fix
The final chomp needs the rival at 35 health or less and never fires on the clock; a stomp hurts the rival only when the player faces it within half reach; rival skill is 0.7, 1.0 or 1.3. A run with the player never attacking ended with the rival at 100 health. It is in the post-submission package, not the submission, and no person has played it.

The arch never sat on the rival's head, and "fixed" was said without a look

fixed
Symptom
Alex asked for the arch as a helmet at 16:13. At 17:55 it floated above the rival. He said at 20:27 it was still not attached and at 20:36 "completely detached from his head", and asked three times for SceneAudit. The submitted build (package 9) still had it floating.
Cause
The robot model Unreal uses is not the one the Blender script describes, so every earlier placement was computed from the wrong model and aimed at an empty spot: the head is about 312 cm forward of where the code assumed and the head bone's up axis differs. The build session also declared the fix done without ever reading an image of it.
Fix
The arch is placed relative to the head bone and re-applied every frame. SceneAudit measured the old placement as MISPLACED by about 283 units and the new one as SEATED in all 158 sampled play frames; the close-ups were read and shown to Alex before the build. In the post-submission package, not the submission. The ball form does not show the arch.

Stick forward did not mean away from the camera

fixed
Symptom
Alex, 19:11: the thumbstick or W key moved the robot in whatever direction it was facing, not the camera's, which made the game "almost impossible to play". He had been playing with a gamepad on Fort.
Cause
The camera's spring arm ignored its world yaw and used a yaw relative to the robot's facing, so the picture turned with the robot. The autopilot never showed it because the autopilot steers the camera itself; only a person with a controller could find it.
Fix
One line: absolute rotation on the spring arm (the Third Person template's behavior). In every package from number 4 (19:19). Alex's later notes are about camera pitch and speed, not direction; I have no note of him confirming the fix in words.

Eaten pieces looked like big primitives stuck on at random

fixed, not yet re-checked in a packaged build
Symptom
In the 2-minute draft, grabbed pieces stayed attached to a bone and landed on random parts of the robot instead of an accessory slot. Alex: "I really hate when it looks like we have big dumb primitives attached to our character in random spots ... it looks like a glitch." He had already asked, on the earlier round, that every added piece snap on like a standard module.
Cause
Eaten pieces were attached to the robot as they were, rather than absorbed by it. The log does not give a deeper cause.
Fix
Pieces now fly in and shrink into the robot, and the designed bodies carry the look; on the ball only the snap-in tiles show. Seen in captures at 17:30; not in a packaged build.

The directed opening did not read

fixed, not yet re-checked in a packaged build
Symptom
In the 2-minute draft the laugh ran long, the hero stood up inside the bench and never looked at the trash can he used, and the bystander was not in the shot while the hero ate.
Cause
Alex's reading: too many looping animations ("we shouldn't loop animations so much"). The notes do not give a code-level cause.
Fix
The opening was redirected from nine beats to seven, with a short laugh, a bystander already in shot who shrugs once, and a look at the trash can before the bench is eaten. Seen in a contact sheet from a Fort run; not played and not in a packaged build.

Fort's second pass found cropped and tilted things

fix not recorded or confirmed
Symptom
Pieces tilted and stuck out of the ball. A rival limb filled the frame in the duel, and a building face filled one still. The rival's portrait was cropped when photographed mid-throw. The results winner was washed out behind smoke and the ball was cropped at the left edge. The small news inset stayed under the big news window.
Cause
Not recorded for each item. The report names where each one showed up in the run's stills.
Fix
Three fixes were written into the source at 16:37 and not compiled then: worn gear hidden on the ball so only the tiles show, no rival portrait while the rival is stunned or in the air, and the small news inset hidden during a flash. No fix is recorded for the limb and building close-ups or the results framing, and I do not know whether the 17:30 captures include the three.

The toon look's first shader had never been compiled for real

fixed
Symptom
The new toon picture look failed to compile its material on its first real use.
Cause
The material read the scene color in a way Unreal only allows in a surface material; a post-process material must use the scene texture input. The earlier test ran in a commandlet (a script-run copy of the editor) without a renderer, which had never compiled the shader, so nothing caught it.
Fix
A helper agent rebuilt the material with wired scene-texture nodes and checked it with the real renderer (91 pixel-shader instructions). A run with the look turned on logged no compile error and its stills show cel bands and ink outlines. Alex saw the stills and liked the look with the CRT and Pop grade, but found too many facets drawn as black lines; a helper reworked the material (thick silhouettes, thin lines only on sharp creases) and the default look is now the toon, CRT and Pop together with the fringe turned down. Seen in captures; no person has played it.

The scale lineup showed the ball at half its real size

fixed
Symptom
Alex asked why the Big Chomp ball looked smaller than the last robot in the lineup image.
Cause
The brief for the helper agent that drew the lineup gave the ball's size as 50 m. In the game it is about 99 m across. The build session wrote that brief and did not check it.
Fix
The image was redrawn with the ball at 99 m (it is the one on this page).

A tower blocked the camera, and three explanations were wrong

fixed
Symptom
In one still from a packaged autopilot run a white tower filled the frame and the robot was half hidden. It was still there after each of the first two fixes.
Cause
A real city tower stood beside the chase camera. The first two fixes used line traces from the camera to the robot (one line, then three heights) and still left it in view; the notes do not say why. A third guess blamed a backdrop skyline block; looking at the still full size showed that was wrong.
Fix
Each standing building's own box is tested against five sight lines and against the camera position, and any building in the way is hidden. In the next packaged run the same moment shows the whole robot. Checked on that one run's stills; no person has played it.

A refused package was tested as if it were new

fixed
Symptom
A smoke test passed, but it had tested the previous package.
Cause
The build lane refused the new package because the drive was below its free-space floor (13.1 GiB free), but the old log still said BUILD SUCCESSFUL, so the next step ran against the old files.
Fix
A new script stops unless the build exited cleanly and the packaged program's timestamp changed. Space was made by removing a copy that was checked byte for byte against the Mac copy first.

The rival's results portrait was a green slab

fixed
Symptom
In a packaged run's results screen the rival's portrait showed a green slab and water, with no robot.
Cause
The portrait camera looked through the live city, so a piece of loot in flight or a wall could fill the photo.
Fix
The portrait now draws only the rival and the pieces seated on it against the sky, from one fixed angle. A later packaged smoke run's results screen showed the red robot with its gear. Checked in stills only.

A run that ended mid-jetpack left the winner in the air

fixed
Symptom
On the results screen the winning ball sat at the top-left edge of the frame with empty haze below.
Cause
The robot did not update on the results screen, so one that was flying when the run ended stayed in the air. An A/B test (with and without the fix) on Archie showed this. It is not proven that this was the only cause of the odd framing, because the test used the robot form, not the ball.
Fix
Both robots are now set on the ground when a run ends. In the next packaged smoke run's results screen the ball stood on the ground at the left.

A sound that repeated too often

fixed, not yet re-checked in a packaged build
Symptom
Alex noted at least one sound was badly overused in the trailer and in play.
Cause
A few sounds had a single version and no limit on how often they could play. The notes name the fix, not the exact cause.
Fix
Variants of the common sounds and a per-sound minimum gap between plays were built and compiled, and the log records which variant played. Nobody has listened to the result.

The logo's glow drew as solid rectangles

fixed
Symptom
On the new title screen the glow around the logo showed up as hard-edged boxes.
Cause
The glow used additive blending (a drawing mode that adds light) in the engine's Canvas drawing, and Canvas additive blending ignores a picture's transparency, so the transparent parts of the glow texture were drawn as solid color.
Fix
The glow and sparkle are now drawn alpha-blended instead. The build session's log says the result was seen in stills after the fix. The title still higher on this page is from about 02:50 ET and probably predates the fix (a guess from its file name). No person has checked the title on a screen.

A leftover "finished" file fooled a test, again

fixed
Symptom
A test was fooled by a leftover "finished" file from an earlier run.
Cause
The test relied on a marker file (a small file that says a run finished) that an earlier run had left behind. The log says this had fooled a test before.
Fix
The test script now clears its own leftover files.

The agent's clock times were guesses

fixed
Symptom
Log entries and the first version of this page carried clock times from the evening block onward that were several hours ahead of the real time.
Cause
The build agent wrote times from memory instead of running the date command, and nobody had checked them. A person (Alex) noticed that there were still nearly 20 hours to the deadline.
Fix
The real span was reconstructed (about 16:00 ET November 14 to 00:45 ET November 15), the log was marked SUPERSEDED, and the times on this page were corrected or replaced by "order only". The web session's times come from UTC timestamps and were not affected.

Sound objects freed by the garbage collector mid-run

fixed
Symptom
An access violation in the game's sound function at the end of the first autopilot run.
Cause
Sounds were loaded with LoadObject and cached in a plain TMap. Unreal's garbage collector only knows about references the engine can see, so it freed the sounds while the cache still pointed at them.
Fix
Make the cache a UPROPERTY so the engine tracks it. Later autopilot runs finish the whole loop without the crash.

The build blocked by another editor's Live Coding

fixed
Symptom
"Unable to build while Live Coding is active", after 7 seconds, hit by both the main build and the web build.
Cause
Unreal's build tool refuses to compile while any editor on the same engine has Live Coding (instant code reload) switched on, whatever project that editor has open. A class-project editor was open on the shared engine.
Fix
Pass -NoHotReloadFromIDE for our own project's builds. The main compile (12 actions, 78 seconds) and the web template package both went through afterward.

Packaging settings in the wrong ini file

fixed, not yet re-checked in a packaged build
Symptom
The web copy had no audio.
Cause
ProjectPackagingSettings and GeneralProjectSettings were in DefaultEngine.ini but are read from the Game config. The sounds are loaded by path, so nothing told the cooker to include them.
Fix
Moved to DefaultGame.ini. The web copy's console then showed no missing-sound lines and its audio worklet runs; nobody has listened to the audio in any build.

The rival AI stuck on walls

fixed
Symptom
On the new city the rival ate 5 tons in two minutes.
Cause
It targeted the nearest food in a straight line and could not get past buildings taller than it could chew.
Fix
Target scoring penalizes paths that cross a too-tall building, and a robot pushed back by a wall slides along it. In the next autopilot test run the rival reached about 1.5 and was defeated at 102 seconds. Checked by autopilot only.

A jam rule that made us rebuild the city during the jam

a jam rule, not a bug
Symptom
The city the game started with could not be shown to be made during the jam.
Cause
The jam requires levels, gameplay and art to be created during the jam. The harbor city was made before it, for a class whose date overlaps the jam's opening.
Fix
A helper agent generated a new city by script from engine basic shapes and 20 new materials. The Synty pack is excluded from the cook; the class map is not used by the game and is required to stay out of the build.

The web build crashed in Shipping

worked around, cause unknown
Symptom
"memory access out of bounds" right after engine start, on the main thread and on the render thread in different builds. The Development build ran.
Cause
Not known inside the engine. Our first hypothesis, too little initial memory, was tested and ruled out, as were a thread race and a class-layout mismatch. Single-threaded, the heap was corrupted while the game's CityDirector auto-registered three instanced-mesh components created in its constructor.
Fix
Register those components from BeginPlay instead. The Shipping web build then boots in Chrome. The workaround does not explain why the engine's prebuilt web libraries fail; that is an unverified guess (an instanced-mesh render-state bug).

The first video cut was thrown away

fixed
Symptom
Review of the rendered footage found cameras against walls and shots of the rival's buildings with no robot in frame.
Cause
Camera positions were not checked against the city's geometry, and the crush camera followed the rival's crush events as well as the player's.
Fix
Several candidate positions are tested with a line trace and a sphere sweep, and the crush camera is limited to the player's events. The new footage showed the robot in every sampled shot.

Five replay and state bugs found by an outside review

fixed
Symptom
Rewinding the replay left buildings missing; a rocket landing erased earned strength; the beaten rival's gear floated around nothing; a replay ending in ball form flipped to the robot on its last frame; the skinny start replayed as bulky.
Cause
Replay evaluation did not set a flag it cleared, a temporary strength boost overwrote a permanent gain, trophy gear stayed visible after its owner was hidden, endpoint samples did not copy the ball fields, and samples did not store body width.
Fix
All five were applied and compiled. A later autopilot run checked two of them: the replay opens on the skinny robot and ends in ball form. No person has checked any of the five.
Smaller snags (8)
  • An Unreal Editor started from an SSH session lands in a session with no display and dies with DXGI_ERROR_NOT_CURRENTLY_AVAILABLE. Anything with a window or a GPU now starts through a scheduled task.
  • ffmpeg 9 removed -filter_complex_script. The replacement is -/filter_complex with a file.
  • Git Bash rewrote -map=/Game/Maps/... into a Windows path under Program Files, so the cook could not find the map. Fixed with MSYS2_ARG_CONV_EXCL.
  • A cmd batch file split the same argument at the equals sign. Fixed by reading the tail of the argument line verbatim.
  • The web copy of the project was taken while the main session was mid-edit and failed to compile on a shadowed variable. It was fixed in the copy and re-synced.
  • The Movie Render Pipeline plugin must be disabled outright for a web cook; restricting it to the editor is not enough.
  • Compiling the UE 5.8 DLSS plugin for 5.9 failed on enums and 64-bit integers passed to %d format strings, which the newer engine rejects. Fourteen one-line fixes.
  • Unreal's Python API has no unreal.FontData, so the imported pixel font is wrapped in a runtime font in C++.

Tools used

Tools

  • Claude Code (Anthropic): Claude Fable 5.2 and Claude Sonnet 5.5

    The build and web sessions, the helper agents, and the native MCP work in Unreal Editor 5.9. The log credits Fable 5.2 for the robot and the Sequencer film; for the rest it names both models without saying which did what.

  • OpenAI Codex (CLI 0.167.0)

    Two read-only code reviews. The first, of the game source, took about ten minutes and found five real bugs, all fixed. The second, of the animation crossfades and the camera fix, found two small state bugs, both fixed. No other Codex use is recorded.

  • Unreal Engine 5.9 (MegaJam Preview)

    The engine, in the installed binary build, with a C++ game module and the engine's native MCP.

  • Blender 4.5

    Scripted robot modeling, the final-form ball, and (by helper agents, per the build session) the animation clips, the plain starter robot, the five body stages and the props. Blender 4.5 is named for the original robot; the later scripts are not tied to a version in the notes.

  • ffmpeg

    All sound synthesis, video encodes, the cut of the draft trailer, and the stills and contact sheets used for review.

  • Suno

    One music track under the draft video (Pro plan, commercial rights).

  • NVIDIA DLSS

    The UE 5.8 plugin (DLSS 4.5) compiled for 5.9 by a helper agent.

  • SceneAudit (Alex's repository, github.com/ibrews/SceneAudit)

    Measures 3D placement and says SEATED or MISPLACED in centimeters, with side views. Used after the deadline to measure the arch against the rival's head; it showed the old placement was about 283 units off.

  • Python

    The city generator and the audio script, plus the build and capture helpers.

  • Pixelify Sans

    The HUD font, under the SIL Open Font License.

  • Emscripten 6.0.10

    The web build's toolchain (web session only).

  • Headless Chrome

    Capturing the web crash's stack and running browser boot checks.

Pre-jam work and third-party assets

Declarations

These follow the project log, with the first line reworded to remove a contradiction. The robot's dates (November 12 to 14) fall inside the jam, which opened on November 12, so it is declared here as work that started on the jam's first day, not as clearly pre-jam.

  • Harbor city layout 07_HarborMetropolis and the class kit: made for the Small Worlds Part 2 workshop (Alex Coulombe Presents, class held 2026-11-12). The jam opened 2026-11-12 at 00:00 EST, so the class fell on the jam's first day. It is not claimed as jam work, and the game does not use it.
  • Lantern Devourer robot (Blender script build_colossus.py, imported into Unreal Engine) and the Sequencer film, versions 1 to 4: built 2026-11-12 to 2026-11-14 with Claude Fable 5.2 on Unreal Engine 5.9 through its native MCP. The planner scripts are kept in the author's tooling repository.
  • Third-party and Fab assets: the log's running list still reads "none yet". Items added since the log's first entry are listed below.

What changed since

  • Since those lines were written: the game's city is a new map generated on 2026-11-14 by a script from engine basic shapes (see the timeline). The class map is not used. The Synty pack that sits in the class project is not referenced and is excluded from the cook. The first playtest video above still shows the class city.
  • The robot's assets, and the burst effect materials used for crush effects, ship with the game. The log gives dates for the robot (November 12 to 14) but not for the burst materials, so their dates are unverified.
  • The game's sound effects and score are synthesized with ffmpeg. Earlier scripts (building grouping, burst effects, animations) were reused as tools.
  • Added since: the Pixelify Sans font (SIL Open Font License; the license text ships with the game), NVIDIA's DLSS plugin (compiled from NVIDIA's 5.8 package; NVIDIA's license text ships with the game) and one Suno track under the draft video. A Synty Polygon City pack sits in the project folder but is excluded from the cook.

Urban Chomp is Alex's solo jam entry, published here by Alex Coulombe Presents. Alex submitted it himself, before the deadline. This page is edited as the build changes, so check the date at the top.