GPT-6 Astra vs Claude Fable 5.1: Hill Climb

Every previous round of this series has carried the same line in the brief: write the file and stop, you will not see it run. The faults that decided those rounds were nearly all of one kind — a carousel that never turned, a rocket flight whose sequence ended at “ascent”, ghosts that rode the walls instead of the corridors. Each was the sort of thing a model catches in seconds by opening what it made. So the standing excuse held: these are failures of finishing, not of capability.

This round takes the excuse away. Both models were told to run what they built, exercise it, look at it and fix what they found, with a single hard stop: the moment either reported it was done, the file was frozen and judged exactly as it stood. Verifying was not merely permitted, it was demanded, and time spent on it was explicitly not held against them.

They both took the invitation seriously. OpenAI’s GPT-6 Astra wrote six test harnesses and drove a real Chrome. Anthropic’s Claude Fable 5.1 wrote four physics harnesses and drove a real Chrome. Between them they produced more than thirty screenshots, ran the physics at frame rates from 30 to 144, and tested their own games inside a sandboxed iframe with storage blocked.

Both still shipped a fault that a reader finds in the first minute of play. The round went to Fable 5.1 by a single point, 15–14, the narrowest result this series has recorded.

Play them both

Both builds run below exactly as the models wrote them, nothing added and nothing tidied. Arrow keys or WASD on a desktop, the on-screen pedals on a phone. Click into a game before using the keyboard.

Ridgeline — GPT-6 Astra, 28 minutes 24 seconds.

Ridge Runner — Claude Fable 5.1, 75 minutes 38 seconds.

The brief

Recreate Hill Climb Racing as one self-contained HTML file: everything inline, no CDN, no network, no images, all art drawn in code. It had to survive an iframe sandboxed with allow-scripts only — no local storage, no cookies — because that is how it is embedded on this page. Three screens in a loop with no dead ends: an opening screen, a menu, and the game itself with one level. A two-wheeled vehicle with suspension over hilly terrain, a camera that follows it, throttle and brake on the keyboard and as touch controls, a real fail state, a restart that does not reload the page, and physics not tied to the frame rate.

What the brief never mentioned was fuel or coins — the two things Hill Climb Racing is actually built around. In earlier rounds the rule has been that a trap named in the brief gets solved and an unnamed one of equal difficulty gets approximated. Both models shipped fuel and coins unprompted. Both knew the game.

Ridgeline, by GPT-6 Astra

Astra took 28 minutes 24 seconds and 53 KB. It built a warm desert in flat editorial colour: sand, teal and terracotta, a buggy drawn with more mechanical detail than anything else in the round, and a menu that reads like the inside page of a travel magazine — a route profile of the hills ahead, a distance to the lookout, a fuel-stop count, a difficulty rating.

Ridge Runner, by Claude Fable 5.1

Fable took 75 minutes 38 seconds and 81 KB, and assembled it from nine source files through a build script of its own making. Its choice is the opposite one: bright arcade colour, a hard sun, a chunky orange jeep, a title screen where a bot drives the real physics behind the logo. It is the build that looks more like the game it is copying, and it is the one that feels quicker under the thumb.

What they actually checked

This is the part the round exists to observe, and neither model coasted.

Astra wrote harnesses for physics, invariants and tuning, then automated a real Chrome over the DevTools protocol and walked its own game through every screen: opening, menu, driving, airborne, crash, out of fuel, finish line, pause, plus a small-screen pass. It ran 18 stress runs and checked that the simulation agrees with itself between 30 and 144 frames per second. It loaded the finished file inside an allow-scripts iframe with storage blocked, which is exactly the condition this page imposes.

Fable wrote a rest test (0.000 mm of drift), a fuzzer across 24 random throttle-and-brake policies, 25-metre drops onto flat ground and onto a 41° slope at 21.7 m/s, and a jump tracer. It drove its own step function at a steady 60 fps, a steady 30 fps and a jittery 4–100 ms pattern and got bit-identical end states. It screenshotted every screen at three viewports including a 390×700 portrait phone, ran the game inside a sandboxed iframe at three sizes, and confirmed through performance.getEntriesByType('resource') that the page makes no network requests at all.

Read those two paragraphs again and the round looks like it should have produced two clean builds.

What they missed

Fable’s level hangs 32 of its 117 coins in arcs over the four jumps, and almost none of them can be collected. The cause is one argument. The 85 coins in the ground rows are placed at terrain.groundY(x) - 1.35 — the surface directly beneath each coin, always within reach. Four lines later, the arc coins are placed at terrain.groundY(j[0]) - arc: the ground height at the start of the jump, a single fixed reference, while the arc runs 18 metres downrange and adds up to 8 metres on top of it. The arc never looks at the terrain underneath itself.

Replaying Fable’s own physics engine into each jump at full throttle from 60 metres back, and measuring height above ground with the same expression its own tracer uses:

Jump	Car’s apex	Coin heights above the surface	Reachable
380 m	2.1 m	3.4 · 6.3 · 8.7 · 9.7 · 10.0 · 10.1 · 9.5 · 7.9	0 of 8
560 m	1.9 m	2.7 · 5.5 · 8.6 · 10.3 · 10.6 · 10.6 · 10.3 · 9.5	0 of 8
715 m	2.4 m	4.6 · 9.6 · 13.6 · 16.2 · 17.6 · 17.3 · 15.3 · 12.9	0 of 8
830 m	4.2 m	3.4 · 6.6 · 9.5 · 11.6 · 12.3 · 10.6 · 7.5 · 4.7	1 of 8

The finish panel further up says the same thing from the other direction. That run drove the level end to end at full throttle and came home with 85 coins — exactly the number of coins in the ground rows, and not one of the 32 in the arcs.

Now the uncomfortable part. Fable wrote the instrument that finds this. Its jump tracer drives the vehicle off the first ramp under three different control policies and prints, among other things, maxH=2.6m. It ran that harness. It reported the number. It never compared the number with the heights it had hung in the air.

Astra’s two faults are smaller and both sit in the presentation layer. Three birds hang in the canyon behind the buggy, and they are static: their horizontal position includes the camera offset so they drift with the parallax, but their height is a constant and nothing in the expression that draws them is a function of time. They never flap and they never fly. And the audio is close to inaudible — the engine drone is held at a gain of 0.026 and one-shot effects default to 0.07, against Fable’s 0.8 master and 0.45 engine. Astra also ships with sound off until you switch it on. Turn it up to the top of the dial and the engine is there; at a normal volume the game is silent.

Time, tokens and what the round cost

Astra was faster by a factor of 2.7, which is the same direction every cross-lab round has gone so far.

	GPT-6 Astra	Claude Fable 5.1
Setting	Extra High	MAX
Wall clock	28 min 24 s	75 min 38 s
Delivered file	53 KB, 222 lines	81 KB, 1,529 lines
Tokens reported	141,245	358,999
List price	$10 per million in, $50 per million out — the same for both

Those token totals come from each harness’s own accounting and are not guaranteed to count the same things, so read the ratio rather than the absolute figures: Fable spent roughly two and a half times the tokens and two and a half times the wall clock for a one-point win. At list prices the two models are identical per token, which makes the token ratio the cost ratio — and on a rough agentic split that lands near two dollars against five.

Scoring

Category	GPT-6 Astra	Claude Fable 5.1
Graphics	3	4
Physics	4	4
Sound	3	4
Gameplay	4	3
Total	14	15

Graphics went to Fable on the strength of the direction rather than the draughtsmanship: Astra’s buggy is the better-drawn object and its palette is the more sophisticated one, but Fable’s brighter register is the one that pulls the eye and the one that reads as this kind of game. Physics was a draw — both vehicles drive as they should, suspension and all. Sound went to Fable on audibility. Gameplay went to Astra, and only because of the coins: Fable’s game is the more enjoyable one to drive right up to the point where you watch a row of coins sail past overhead.

What the round shows

Letting a model check its own work did not produce a clean build. It produced a confident report. Astra signed off with the sentence “no known unfinished or broken features”; Fable volunteered three limitations, and the coins were not among them.

What both models verified was the engine: integrator stability, penetration depth, frame-rate independence, the screen graph, the sandbox. What neither verified was the level — whether the thing built on top of that engine is playable as designed. Every check they ran was a check that passes on a correct engine carrying a broken level. The fault that decided the round was not beyond either model’s reach; it is two numbers, in two files, one of which Fable had already printed.

That is a narrower and more useful finding than the one the old format produced. It is not that these models cannot test their work. It is that, left to choose what to test, they test the machinery and not the experience.

How this test was run

One attempt each, the same prompt to both apart from the output path, no follow-up messages and no clean-up: both files are served exactly as the models wrote them. Fable 5.1 ran as a Claude Code subagent at maximum effort; GPT-6 Astra ran in OpenAI’s Codex CLI at Extra High. Identical prompt, different scaffolding. Both were told to verify before reporting done, and both had a shell, Node and a browser available to do it with. Scoring was done by BitsMinds across four categories from a local side-by-side page, playing both games in an ordinary browser rather than in any preview tool; the coin measurements above were made afterwards by replaying the delivered build’s own physics code.

Earlier rounds: the same two models on three briefs, and Claude Opus 5 against GPT-5.6 Sol, both under the old no-checking rule.