AI game builders report weeks of cleanup after fast agent-made demos

• Fast AI game demos are cheap; games people actually want still take cleanup: AIandDesign put the gap at one afternoon for a demo video and another month or more for playability.
• One-prompt games are mostly long agent runs now: om_patel5 described a five-hour Worms-style build with subagents, headless Chrome, and a claimed 1 billion tokens burned.
• Visual self-audit is still the blocker: karpathy had Opus 5 spend about two hours and 5,500 lines on a Three.js Lord of the Rings scene, then pointed to slow screenshot-based checking as the weak link.
• Model choice has become part of the craft: kaigani said they use Fable, Opus, and GPT 5.6 Sol across kids games, while AIandDesign said GPT fixed 3D topology issues Fable kept missing.
• The strongest posts looked like live systems, not static demos: michaelmicasso shipped anonymous message passing in Red Writer, and AIandDesign described Liminal Spaces as a nine-zone survival loop.

The Claude Code subagents docs define the pattern behind many of these demos: separate agents with independent context, tool access, and permissions. A We0 breakdown called the game-building version a loop of specialist builders, critic agents, quality gates, and repeated verification. The Sakura Crossing repo shows the kind of code-only Three.js world agents are now remixing: real geometry, runtime Canvas2D signs, and no image assets. A FirstPlayable README put the product bar cleanly: a feature is done when it survives compilation, tests, a real scene run, and hands on keyboard.

AIandDesign has shipped enough AI-built game work to draw a hard line between a social clip and a playable thing: one afternoon can make a cool-looking video, while the next month decides whether anyone wants to play it.

thekitze hit the same wall after trying a Three.js game, saying a game needs weeks, months, or years of polish before people stop quitting after five minutes. thekitze still argued Opus 5 is good enough for small games in the Super Meat Boy, Brotato, or Vampire Survivors class, where the hard part is idea quality rather than AAA graphics.

The demo wave was real. minchoi rounded up ten Opus 5 game examples, and minchoi said planned prompts can be enough for that kind of build.

The product critique came from petergyang, who listed the pieces a graphics-first one-shot leaves open:

• core loops
• progression systems
• story
• human taste
• busy-work reduction for actual studios and developers

A RetroStyle Games case study landed in the same range: two evenings for a working Claude Code prototype, six weeks for a live text RPG that coworkers played nightly.

The new viral prompt shape is less “make me a game” and more “run a tiny studio until the critic stops complaining.”

chrisfirst’s Fallout prompt asked Claude Code to:

• fan out subagents for terrain, environmental storytelling, Pip-Boy UI, weapons, armor, NPC dialogue, and art direction
• loop on each item
• assign a separate harsh visual critic
• compare output against Fallout side by side
• build the whole thing in Three.js
• keep iterating until the subagents were “wowed”

chrisfirst said the run was “all Claude Code.” chrisfirst later said the result was a 2.3 MB HTML file before an updated 3.1 MB upload, and chrisfirst called it a buggy tech demo with glitches and bad dialogue.

om_patel5 described a similar Worms-style run with more implementation detail:

• five hours of execution
• agents for sky, terrain, worms, and critics
• headless Chrome used to play and test
• no image files, sprites, PNGs, or textures
• 62 weapon icons drawn with canvas calls
• procedural terrain with seamless tiled noise
• worms drawn from signed distance fields
• terrain destruction handled through a bitmask
• one offline HTML file
• a claimed $717 API-price equivalent on 1 billion tokens

levelsio showed the other side of one-shot geography with a 1660 New Amsterdam scene based on historical maps. It was impressive enough to walk through, but the posted bug list included canal weirdness, open house edges, and a windmill that did not look Dutch.

karpathy gave Opus 5 the first paragraph of The Lord of the Rings, a 1 million token budget of about $10, and a request for a Three.js render. The run went for about two hours and wrote 5,500 lines that procedurally placed and animated a low-poly story world.

The failure mode was perception. karpathy said Opus had to audit the output by slowly taking screenshots at different points, which led to jank and missed problems.

DannyLimanseta called limited visual capability the biggest bottleneck for AI-built games. DannyLimanseta narrowed the complaint to practical UI work: models can be strong at everything else while still failing to copy a UI faithfully or catch obvious alignment errors.

Video models are being tested against the same pain point from another direction. koldo2k used Hailuo Minimax H3 to recreate gameplay and singled out stable HUD preservation and context-aware interface reactions.

AIandDesign’s Liminal Spaces moved from environment porn into a playable horror structure. The project had 35,000 lines of Godot code in the thread context, with Fable running a refactor to keep the codebase manageable.

The current loop:

• enter a zone from an elevator
• use a compass to find the next elevator
• escape through nine liminal spaces
• avoid ghost-like demons
• kill ghosts with a flashlight that loses power and recharges
• keep moving because ghosts stop following after room transitions
• look away and back to trigger a Weeping Angels-style jump closer

AIandDesign added blackouts, where the player has to stop moving while the lights go out and ghosts freeze. One planned variant changes the environment after the blackout, making the space feel alive.

The visual iteration was expensive. AIandDesign said the Pool Rooms ran through a whole Codex reset and several Fable 5-hour windows, while AIandDesign called the project “AI art in code” after putting in an obscene amount of time and tokens.

The worldbuilding kept moving too. AIandDesign added creepy Liminal Inc. posters, and AIandDesign showed them placed inside the environment.

Red Writer is a smaller build with a cleaner social mechanic: each player receives a previous anonymous drawing or note, makes their own response, and passes it to the next online player.

michaelmicasso later added a live gallery of player drawings and messages. michaelmicasso framed the gallery as a showcase of what people wrote and drew in-game.

The production workflow was the interesting part:

• assets were made in Figma, according to michaelmicasso
• vibe coding plus manual searches handled implementation, according to michaelmicasso
• Figma doubled as a logicboard and storyboard, with components and commands latched into layer names, according to michaelmicasso
• the build was just TypeScript, according to michaelmicasso
• michaelmicasso called it a two-day gamedev sprint

michaelmicasso described the core object plainly: an online anonymous message-passing game.

No one in the thread settled on one model for games. The more useful pattern was task routing.

kaigani said they had made more than a dozen QLOBE Kids games with Fable, Opus, and GPT 5.6 Sol, were leaning toward GPT 5.6 Sol as the main model, and still planned to use Fable for large platform changes. kaigani pointed another user toward songadaymann when the topic was AI-made games.

AIandDesign’s model notes were narrower and more practical:

• GPT fixed 3D topology issues that Fable kept missing, according to AIandDesign
• Sol 5.6 nailed rounded pool-room corners after Fable made a mess of them, according to AIandDesign
• Codex nailed rounded corners and entrances in the Pool Rooms pass, according to AIandDesign

MengTo ran a two-agent stack instead of a single-model stack. MengTo had Codex use the Claude Code CLI while both worked on a Sakura Crossing inspired Three.js build, and MengTo called Codex the command center.

The original Sakura Crossing repo is a useful reference point because it is already an asset-free Three.js world: Node 18+, Three.js, Vite, runtime Canvas2D details, real geometry, and no image assets in source.

For visual generation rather than game code, magnific said Fable 5 leaned toward wider staging and smoother camera motion, while Opus 5 stayed closer to the original idea with tighter framing and heavier texture. magnific summed up the split as Fable for moving shots and Opus for weight in the frame.

Shipping the demo produced its own pile of normal game-dev problems. AIandDesign posted Mac and Windows builds of Liminal Spaces, then quickly found the Windows build was broken.

AIandDesign followed with a Direct3D-first Windows version for testers. The Godot Windows export docs describe the ordinary packaging path behind that pain: exporting a project into a Windows executable plus bundled project data, then compressing and distributing it.

Quota limits were part of the workflow, not a footnote. AIandDesign said Liminal Spaces ripped through two resets plus a regular allotment, and AIandDesign showed a Max plan session at 100 percent with more than three hours until reset.

The model was not the only problem. AIandDesign said the 5-hour Fable windows were the awful part, not Fable itself, and AIandDesign said Ultra wasted time in overthinking loops until switching to xhigh fixed the run.