Editor's note: We ran this bake-off during Claude Fable 5's brief free-access window in June. Access was pulled shortly after and has since come back, though still somewhat restricted. Either way, the four builds it produced are already live and playable, so the experiment stands on its own.
Same fruit. Two models. Whose jam is sweeter?
A model-vs-model coding experiment — play all four builds at tryfable.ai.rs.
The idea
There's a game called Apricots. Despite the name it has nothing to do with fruit — it's a fast little side-view plane game with roots on the Amiga in 1991: you take off from a runway, fly a tiny plane around a scrolling landscape, shoot enemy planes, drop bombs on ground targets, and dodge anti-aircraft fire. It's quick, it's arcadey, and it's the kind of thing that took a skilled programmer months to build in hand-tuned assembly and BLITZ BASIC, later ported to C++/SDL.
So we asked a simple question: can a large language model rebuild it from scratch, in one shot? And a more interesting one: which model does it best?
To find out, we ran a controlled bake-off between two Claude models:
- Fable 5 (
claude-fable-5) — the model under test - Sonnet 5 (
claude-sonnet-5) — the baseline
Same brief. Same constraints. No human touching the game code. Two tracks each.
The rules
First we did our homework. We took the original C++/SDL source of Apricots and reverse-engineered it into a precise specification — the real flight physics (a 16-direction rotation model, pitch-driven speed where diving builds airspeed and climbing bleeds it, a stall that drops you unless you nose down to recover), the weapon timings, the anti-aircraft lead-prediction, the scoring economy (down to "bombing a civilian building costs you points"), and a 23-item fidelity checklist. That spec became the shared brief.
Then each model got two assignments:
- The 2D port — reproduce the original's feel on an HTML5
<canvas>. - The 3D reimagining — re-cast the same game as a low-poly Three.js flight-combat arena.
Two hard constraints made the results comparable and honest:
- One self-contained file. No downloaded art. No audio files. Every sprite drawn in code, every sound synthesized live with the WebAudio API, the whole world generated procedurally.
- It has to actually run. No "here's a sketch" — a real, playable game.
How we checked the work
Every build was loaded in a headless Chromium browser and held to an objective bar before a single opinion was formed:
- Does it parse and load?
- Zero console errors or uncaught exceptions?
- Does it render something real (not a blank canvas)?
- Is it genuinely self-contained (no sneaky external assets)?
All four builds cleared it. One capture even caught a Fable plane mid-mission — it had taken off, scored, bombed a row of ground targets into burning wrecks, crashed, and hit the RESPAWNING state — proof the whole combat-and-respawn loop works end to end, not just the opening frame.
Then, for the subjective half, we brought in an independent judge (a third model, Opus, which wasn't one of the two contestants — so nobody grades their own homework). It read the actual source of each build, studied the screenshots, and scored every game against the spec on flight feel, combat, world density, visual craft, and AI opponent quality.
Play first — then peek
Before we tell you who won, go play them and form your own verdict. It takes two minutes and it's more fun blind. Pick a plane with the number keys, arrows to fly, hold up to climb, space to shoot:
- 🕹️ Fable 5 · 2D vs Sonnet 5 · 2D
- 🕹️ Fable 5 · 3D vs Sonnet 5 · 3D
Which one feels better to you? Got an answer? Now open the box below.
🚨 SPOILER — reveal our benchmark scores & verdict
The scorecards
Both models cleared the objective bar. Then the independent Opus judge scored each build out of 100. Here's how it shook out:
| Track | Fable 5 | Sonnet 5 | Winner |
|---|---|---|---|
| 2D — Faithful Port | 88 | 73 | 🏆 Fable 5 |
| 3D — Reimagining | 96 | 89 | 🏆 Fable 5 |
| Average | 92 | 81 | 🏆 Fable 5 |
2D — Faithful Port → Fable 5 (88 vs 73)
| Dimension | Fable 5 | Sonnet 5 |
|---|---|---|
| Spec fidelity (of 23 items) | 4/5 (18/23) | 4/5 (17/23) |
| Flight model | 5/5 | 4/5 |
| Combat & world | 5/5 | 4/5 |
| Visual craft | 4/5 | 3/5 |
| AI opponent | 4/5 | 3/5 |
| Overall / 100 | 88 | 73 |
Both are clean, error-free ports that get the flight physics right — the pitch-driven speed, the stall that only recovers when you nose straight down, the destructible economy where bombing a civilian building costs you points. Fable pulls ahead on execution: it draws genuine 16-direction pixel-art sprites and a custom pixel font, where Sonnet's plane is a tiny vector triangle labelled with browser text. And Fable's computer opponent is materially smarter — it leads its gun shots and solves a little quadratic to time its bomb drops, while Sonnet's AI aims straight at you and releases bombs on a coin-flip. Sonnet's nicest touches: a properly rotating bomb sprite and a clean "press R to restart."
3D — Reimagining → Fable 5 (96 vs 89)
| Dimension | Fable 5 | Sonnet 5 |
|---|---|---|
| Faithfulness in spirit | 5/5 | 5/5 |
| Flight model | 5/5 | 4/5 |
| Combat & world density | 5/5 | 5/5 |
| 3D craft & polish | 4/5 | 4/5 |
| AI opponent | 5/5 | 4/5 |
| Overall / 100 | 96 | 89 |
This was the closer, higher-quality track — two genuinely dense low-poly worlds with matching scoring economies, real stalls, and anti-aircraft guns that swivel and lead their targets. Fable wins on the feel: a flight model with accumulating "sink" in a stall and speed-scaled turning, and a genuinely elaborate 7-state AI that takes off, picks targets, makes predictive bombing runs, and even flies a proper landing approach with a go-around. The twist: Sonnet's renderer is actually the prettier one — it enables soft shadows, ACES tonemapping and a real shadow under the plane, which Fable never turns on (so Fable's world looks a touch flat). But Sonnet undercuts itself with a hangar that renders as a big black dome dominating the opening shot, plus a coarser flight model and a "hold Down to take off" quirk.
What we learned
The headline isn't just "Fable won." It's that both models one-shot a real, playable, faithful arcade game — flight physics, exploding towers, lead-aiming flak, a competent AI wingman-turned-enemy — from a text brief, entirely procedurally, in a single file, with zero runtime errors. A few years ago that would have been a person's side project for a season.
Fable's winning margin comes from depth of simulation. Wherever both models implemented a feature, Fable tended to implement the more sophisticated version: real lead-intercept instead of straight aim, a sink-based stall instead of a linear one, a landing approach with a go-around instead of a simple touchdown gate. Sonnet's standout is the 3D rendering pipeline, a reminder that "which model is better" partly depends on which axis you weight — physics and AI, or lighting and polish. Fable took four of five dimensions in both tracks; Sonnet's clearest single win was looking good.
Try it yourself
The best judge is you. All four builds are live and playable in your browser — pick a plane on the runway with the number keys, arrows to fly, hold up to climb, space to shoot:
Everything you see was written by a model from a text brief: the flight physics, the exploding towers, the anti-aircraft guns leading their shots, the golden-hour lighting, the sound of the engine. No art assets, no libraries beyond Three.js, one file each.
Based on Apricots by Jonathan Marsh (Amiga, 1991; C++/SDL port, 2002). A non-commercial technical demonstration; all game code is machine-generated. Play at tryfable.ai.rs.