I Built the Same Game With Astra and Fable 5.1. One Won.
In this article
Bottom line: I built an identical browser-based Asteroids clone twice — once with Astra, once with Claude's Fable 5.1 — using the same prompts, same scope, and a 90-minute clock for each.
Fable 5.1 shipped a playable, bug-free build in 52 minutes with working collision detection on the first try; Astra needed three separate debugging passes and still had a ship-through-asteroid hitbox bug at the 90-minute mark.
Fable 5.1 also used roughly 40% fewer follow-up prompts to get from skeleton to polished.
If you're picking a coding assistant for anything with real-time physics or state management, this test says the gap isn't marketing — it's real.
I've built the same toy project with a dozen different AI coding tools over the past year, mostly to settle arguments in my own head.
Most of the time the results are close enough that picking a winner feels like splitting hairs.
This time it wasn't close. I timed it, I logged every prompt, and I still don't fully believe my own spreadsheet.
The Setup
Here's the thing about testing AI coding tools with to-do apps and CRUD boilerplate: it's meaningless. Every model on the market can spit out a to-do list with authentication in four minutes flat.
That tells you nothing about how a tool handles actual complexity — state that changes 60 times a second, physics, collision math, edge cases that only show up when you're actually playing the thing.
So I picked a small Asteroids-style shooter. Single HTML file, canvas rendering, no external libraries.
Ship rotation and thrust, asteroid spawning and splitting, bullet collision, a score counter, and a game-over state.
Small enough to finish in one sitting, complex enough that a sloppy AI can't fake its way through.
I gave Astra and Fable 5.1 the exact same opening prompt, word for word.
Then I let each one run its own course from there — following up, debugging, asking for polish — however each tool's own workflow naturally pulled me.
The Rules of the Test
I wasn't trying to rig this. Both tools got:
- The same initial prompt, copy-pasted character for character
- A 90-minute hard cap, timed on my phone
- Zero manual code edits from me — if something broke, I described the bug in plain English and let the AI fix it
- The same success bar: a shippable, playable game with no visible bugs
I logged every prompt, every response time, and every moment I said "wait, that's not right" out loud in my apartment like a lunatic.
Round 1 — First Impressions
Astra came out fast. Within about 90 seconds I had a full HTML file with a canvas element, a game loop, and a triangle ship that rotated with the arrow keys.
Genuinely impressive first draft — better than I expected going in.
Then I hit play. The ship rotated fine. Thrust worked.
But asteroids weren't spawning at the edges like I'd asked — they spawned in a tight cluster near the center, so the game was unplayable within four seconds every single time. I described the bug.
Astra apologized, rewrote the spawn function, and introduced a new bug where asteroids spawned off-screen entirely and never appeared.
Fable 5.1's first draft took a little longer to generate — closer to two and a half minutes — but when I hit play, the asteroids spawned correctly at the edges, drifted inward at varied speeds, and wrapped around screen edges the way I'd described.
No bug. First try.
I want to be clear I wasn't expecting that. I've tested enough of these tools to assume round one always has something broken. Writing "no bug, first try" in my notes felt like a typo.
Round 2 — The Deep Test
This is where it actually got interesting, because a working first draft doesn't mean much if the tool falls apart under real pressure.
I pushed both harder — collision detection, game feel, and debugging under a genuinely gnarly edge case.
Collision Detection
Asteroids-style collision is deceptively hard: bullets need to hit asteroids, asteroids need to split into smaller ones on impact, and the ship needs to die on contact — but only after a brief invincibility window on respawn, or the game becomes unplayable.
Astra's collision math used simple bounding boxes instead of circular distance checks.
That meant a bullet could visually pass right next to an asteroid's corner and still register a "hit" — or worse, visually overlap the asteroid and register nothing.
I flagged it three separate times across three different asteroid sizes before Astra finally switched to distance-based collision.
Even then, the smallest asteroid tier kept a phantom hitbox about 15% larger than its sprite, which was still present when my 90 minutes ran out.
Fable 5.1 used circular distance checks from the start, scaled the hitbox radius to each asteroid tier automatically, and when I asked for the invincibility window, it added a blinking-ship visual cue unprompted — something Astra never did even when I asked for it directly.
Game Feel and Polish
I asked both for the same three polish items: screen shake on ship death, a particle burst when an asteroid splits, and a subtle speed-up in difficulty over time.
Astra handled the screen shake fine. The particle burst worked but reused the same static image instead of scattering fragments, so it looked more like a stamp than an explosion.
The difficulty ramp never actually triggered — I tested it at the two-minute and five-minute marks and asteroid speed was identical.
Fable 5.1 nailed all three on one prompt.
The particle burst scattered actual triangle fragments with randomized velocity, which is a small detail but the kind of thing that separates "AI-generated" from "someone who's played this genre before."
Debugging Under Pressure
I saved the nastiest test for last: I asked both tools to add a "shield power-up" that spawns randomly and gives the ship three hits of protection.
This touches spawning, collision, state, and UI all at once — exactly the kind of change that reveals whether a model actually understands the codebase it wrote or is just pattern-matching on the last message.
Astra's shield implementation broke the existing asteroid-splitting logic.
Somewhere in the diff, it had rewritten a shared collision function instead of extending it, which meant asteroids stopped splitting into smaller pieces on any hit — shielded or not.
That's a real regression, the kind that would sail past a distracted reviewer and end up in production.
Fable 5.1 added the shield as an isolated check before the existing collision logic ran, touching nothing else.
I diffed the file before and after — the only changed lines were the ones directly related to the new feature. That's the difference between a tool that edits and a tool that understands.
It's the same instinct I wrote about when I looked at vibe coder productivity — speed only counts if it doesn't cost you a regression three commits later.
The Results
After 90 minutes per tool and roughly 30 prompts total, here's where it landed:
| Metric | Astra | Fable 5.1 |
|---|---|---|
| Time to first playable build | 1.5 min | 2.5 min |
| Bugs in first draft | 1 (spawn logic) | 0 |
| Total debugging prompts needed | 7 | 4 |
| Regressions introduced while fixing bugs | 2 | 0 |
| Collision accuracy at test end | Phantom hitbox present | Accurate |
| Difficulty ramp working | No | Yes |
| Final build shippable? | No | Yes |
Astra won on raw first-response speed — a full minute faster out of the gate. But speed on the first message doesn't matter much if you spend the next 88 minutes cleaning up after it.
Fable 5.1 needed 40% fewer total prompts to reach a finished, bug-free build, and it never introduced a regression while fixing something else — which, if you've done any real coding with AI assistants, you know is the failure mode that actually eats your afternoon.
What This Means for You
If you're prototyping something quick and disposable — a landing page, a script you'll run once — this test probably doesn't matter to you.
Both tools will get you there fine, and the gap I found only shows up once state and physics get involved.
But if you're building anything with real-time logic, shared state, or systems that touch each other — games, obviously, but also dashboards with live data, animation-heavy UI, anything with a simulation loop — this test suggests the difference is not cosmetic.
Astra's habit of rewriting shared functions instead of isolating changes is exactly the pattern that turns a quick AI-assisted session into a debugging afternoon.
I'd rather spend two extra minutes waiting on a first response than lose 40 minutes to a regression I didn't ask for.
The Twist
The thing that actually surprised me wasn't the bug count — it was that Astra's code looked more confident the whole time.
Clean variable names, tidy comments, a UI that looked more polished in the editor before I ever hit play. Fable 5.1's code was plainer, almost boring by comparison.
Turns out "looks clean" and "is correct" aren't the same thing, and I'd been unconsciously grading on the first one for longer than I want to admit.
Have you run your own head-to-head between coding assistants on something with real complexity, not just a to-do app? I'd genuinely like to know if collision detection breaks other tools the same way.
