Four AI Agents, One Brief, One Line of Prompt. Only One Finished.

TL;DR

• Four agents, one brief, one line of prompt, all at once on one PC: "Read AGENT-START.md and follow it." Each got the same spec, art, check scripts and lessons from Claude Code's build.
• Codex finished in 26.5 minutes with one "continue" from me, for $10.39 of API tokens. Its game is as good as Claude Code's, and its report was accurate.
• Cursor hit its free usage limit after 26 minutes, before its first build. Claude Code finished it in 30 minutes.
• Antigravity stopped after 49 minutes to wait for a test it had started, and never came back. No limit was hit. The game plays, but it looks broken.
• OpenCode worked alone for 7 hours 42 minutes and reported "All 16 scorecard checks PASS". Nothing draws on screen.
• The difference wasn't coding. All four wrote the game rules correctly. The two that look right came from agents that looked at their own screenshots.

---

The last post was Claude Code building one mobile game, Pawn Stack, from a written spec. It took 3 hours 43 minutes, and the tests passed on bugs only my eyes caught.

This post is the part I care about more: what happens when you give the same job to other agents and walk away? Not which one writes better code, but which one finishes, which one tells you the truth about what it finished, and how much of me each one needs.

The Brief

Each agent got one line from me. Everything else was in a file, AGENT-START.md:

• Read: the game spec, the art, and a guide of lessons from Claude Code's run: the difficulty numbers that played well and the traps that cost it hours.
• Record: a journal, a cost log, every message I sent, a scorecard.
• Check: the same scripts for everyone: a scripted play-test, 16 scorecard checks, screenshots at five phone sizes, a gameplay video.
• Done means: every check passes, the screenshots have been looked at, a summary is written.
• Don't: leave your folder, read Claude Code's game, touch git or deploy.

The lessons were on purpose: without them I'd be measuring who trips on the same engine quirks. With them, the question is simpler: can the agent follow a good brief all the way to done?

I started all four within a few minutes of each other and left them alone.

The Scoreboard

* What the same tokens would cost at the provider's API list price. Claude Code ran on my subscription; Antigravity on its free plan.

None of the four showed its usage while it worked, so the numbers come from each tool's own files on my PC:

• Codex: 70 model calls, 97% of the tokens read from cache. It ran on an API key, paid per token at GPT-6 Astra's list price, no free tier: $6.58 of cache reads, $1.97 of cache writes, $1.84 of output.
• OpenCode: 675 responses and 7 context compactions on one message from me. Big Pickle is a free "stealth" model whose maker isn't named, so there's no list price. Data from the free period may be used to improve it.
• Antigravity: 297 model calls, about 40 M tokens, almost all cache reads, from a file format that isn't documented, so treat it as my reading.
• Cursor keeps token counts only on its website. Its local history does name the model Auto picked: Grok 4.5.

Playing Them

Claude Code played all five for me on a phone-sized screen, with real taps timed by watching the claw. First as a good player, landing near the centre; then as a sloppy one, until the tower fell.

Under the art, all five are the same game. The same level length, the same misses hold, the same miss knocks the tower over, the same revive. Every agent turned the written rules into working code. (Cursor's hold rule needed one missing engine setting before it ran; more below.) That part of the job is solved.

What you see is a different story.

Codex: Finished, and Said So Accurately

Codex is the only agent that did the whole job: 16 of 16 checks, the five phone sizes looked at, the video, the summary. Its summary is the only one I'd sign: it listed what it couldn't check (real iPhones and Androids).

Two things stood out in its journal:

• It used the lessons before it needed them. It applied the guide's fixes (untrimmed images, the font fix, the gentler swing, the hold rule) before its first build, instead of rediscovering the bugs.
• It looked. Its first build ran with no errors and every sprite drawn at the wrong size. It caught that from a screenshot, fixed it and moved on.

It even found a bug in my check scripts (the video recorder padded every frame with grey) and said so. And its code is the smallest of the five: fast, small and honest came as a package.

Cursor: Out of Free Usage Before the First Build

Cursor stopped after 26 minutes: "You've hit your free requests limit", until the monthly cycle resets on 1 November. This PC hadn't run Cursor since May, so as far as I can tell that was a full month's free allowance. It had written every screen and popup, about 1,700 lines, and was stuck on an invisible character at the start of one config file that broke every build.

I asked Claude Code to finish it in Cursor's direction: keep Cursor's code and layout, fix only what stopped it from building or passing the checks, and mark every change. That took 12 fixes, 49 lines and 30 minutes ($3.39 at API prices). Every change is labelled in the code and in a FINISHED-BY-CLAUDE.md.

Cursor's direction was right. Its rules passed their tests and almost every button was where the spec put it. One engine setting was missing, so in the game its hold rule never ran, and it didn't get the chance to play the game and notice. The lesson isn't about Cursor's model; it's that a free plan's limit arrives in the middle of a task, not at the end of one.

Antigravity: Stopped to Wait, and Never Came Back

Antigravity's game logic is fine. In my runs it scored exactly what Claude Code's game scored, level for level. Then you look at it:

• The score bar is part of the game world instead of the screen, so it slides down into the play area as the tower grows.
• Popups are see-through: you read CONTINUE? through the tower.
• On game over, the best score says 0.

What bothers me more is how it stopped. Its journal ends 15 minutes in, its scorecard is my blank template, and there's no summary or video. At 49 minutes it started a test in the background, said "I am awaiting the run results" and ended its turn. Nothing woke it when the test finished, and nothing told me. It didn't hit a limit: there's no quota error in its log. Codex got a "continue" from me when it paused; Antigravity didn't, because I didn't notice. I'd have assumed it was still working.

Along the way its code touched physics bodies that didn't exist yet, and the engine threw errors. It wrote a script that patches the engine's own code inside its build to ignore them. The errors went away. Their cause didn't. That's the agent version of taping over a warning light.

OpenCode: Eight Hours Alone, and a Confident Wrong Report

OpenCode is the most interesting run, because it did a lot right:

• It ran unattended for 7 hours 42 minutes on one message, through 7 context compactions, without losing the thread.
• It checked more than it was asked to. It ran a type checker over its own code and found six real bugs before they shipped.
• It reported its own rule breaks. Twice it read files the brief told it not to, and both times it stopped and wrote it in its journal.
• Some of the time wasn't its fault. One build hung for 44 minutes inside Cocos, the same hang that cost Claude Code hours in the last post.

And then it shipped a game where nothing draws. No image reaches the screen: the browser logs about 1,000 graphics errors in 20 seconds of play. The game underneath runs: it cleared the same levels as the others, invisibly. Its summary says:

All 16 scorecard checks PASS. Notable: texSubImage2D warnings observed in console during some runs; gameplay logic remains functional and all validation checks pass.

It saw the error, called it a warning and moved on. Its own screenshots, in its own folder, are blank blue rectangles. It took them, and nothing in its journal says it opened one.

This is the same lesson as the last post, from the other side. Claude Code's first build passed every test with a button that said "REVNE". OpenCode's passed every test with no picture at all. Tests check numbers. Someone has to look.

What I Take From It

• Writing the brief was the best hour of the project. With the lessons, Codex took 26 minutes; without them, Claude Code took 3 hours 43, about 2 of them in hung Cocos builds the guide now prevents. Different models, so not a clean race, but every agent got the rules right because the rules had numbers.
• "Done" is what agents get wrong, not code. Of four agents, one finished, one ran out of free usage, one stopped to wait and one claimed success it didn't have. Only one of the three failures announced itself, so watch for silence.
• Read the report, then check the evidence. OpenCode's summary and its screenshots disagree. The screenshots win. Next time the scorecard gets a check that fails if a screenshot is mostly one colour, so "looking" can't be skipped.
• Free has a ceiling, and you hit it mid-task. Cursor's free plan ran out before its first build. OpenCode's free model ran to the end, in 17 times Codex's time, with a game that doesn't draw. The one finished game cost $10.39 in tokens; the three that didn't finish cost $0.

Play All Five

• Claude Code
• Codex
• Cursor, finished by Claude Code
• Antigravity
• OpenCode

Each is exactly what the agent left, except Cursor's, where every change is marked. On a phone they fill the screen; on a computer they play in a phone-shaped frame.

Try It With Your Agent

Download the kit (1.4 MB): the brief, the spec, the art, the lessons guide and the check scripts. Unzip it, open your agent in that folder and give it the same one line: "you are <tool>. Read AGENT-START.md and follow it." You'll need Cocos Creator 3.8.8, Python with Playwright and ffmpeg; the build script is written for Windows. If you run it, send me your agent's SUMMARY.md.

---

Rather talk it through with other devs first? Join our GameDev AI community.