Claude Fable 5 vs Opus 4.8 vs GPT‑5.5 Codex: which AI builds the best platformer?

What happens if you ask three cutting-edge AI models to build a full Mario-style platformer game from a single prompt—no extra guidance, no manual fixes? This head-to-head test pits Claude Fable 5, Claude Opus 4.8, and GPT‑5.5 Codex against each other to see which one can actually ship the best playable game.

The challenge: one prompt, full game

All three models received the exact same instructions: create a complete 2D platformer in a single HTML file. The requirements were simple but strict:

• Running and jumping
• Enemies and coins
• A win flag at the end
• A lives system

On top of that, the prompt explicitly asked each model to go beyond the basics: add music and sound (generated in code), particle effects, polish, and any extra surprises they could think of.

Each game was then played and scored using a 10-point checklist, with up to 10 points per category for a maximum of 100. The criteria were:

• Runs on first try
• Jump feel
• Collision quality
• Camera behavior
• Enemies
• Coins
• Hazards and lives
• Win/lose states
• Visual polish
• Wow factor (extras like parallax, particles, clever design)

Claude Opus 4.8: polished but needed a fix

Claude Opus 4.8 was the early favorite. It generated a game called “Lumi’s Leap” in about 4.5 minutes, producing a single HTML file with roughly 1,100 lines of code and no external dependencies.

The first impression was strong: a clean, atmospheric color theme, clear controls, and a layout that immediately felt like a classic platformer. Jumping felt responsive, collisions were mostly solid, and the camera tracked the player smoothly.

However, there was one big issue on the first run: some platforms were placed so that they were effectively unreachable. The player character could fall and die repeatedly trying to make jumps that were just too far. This required a follow-up instruction asking Opus to adjust the platform layout to make jumps fair and reachable.

After that fix, the game played well. Enemies could be stomped, coins could be collected, and the win flag worked correctly. Still, the design stayed fairly basic: no boss fight, no advanced hazards, and not much escalation in difficulty. The player wished for more variety—like projectiles, a big final enemy, or more complex patterns.

On the scoring sheet, Opus 4.8 did well on core feel and presentation but lost points for that rough first run and a lack of extra flair:

• Runs first try: 6/10 (needed a layout fix)
• Jump feel: 8/10
• Collision: 8/10
• Camera: 9/10 (best camera of the three)
• Enemies: 7/10
• Coins: 7/10
• Hazards & lives: 7/10
• Win/lose states: 9/10
• Visual polish: 8/10
• Wow factor: 6/10

Final score for Opus 4.8: 75/100.

GPT‑5.5 Codex: technically solid, creatively safe

Next up was GPT‑5.5 Codex, OpenAI’s coding-focused model. Like Opus, it produced a single-file HTML game with around 1,000 lines of code. But Codex did something interesting during generation: it actually tested its own output.

Using an internal browser and Playwright session, Codex ran the game, took screenshots, detected issues, and iterated to fix them—without any extra human prompting. This built-in verification loop is a big advantage for reliability.

The resulting game worked on the first try. Controls were responsive, jump timing felt good, and collisions behaved as expected. As a basic platformer, it did its job.

Visually, though, it looked more cartoonish and less polished than Opus or Fable. The camera had a distracting shake and vertical movement that made the screen feel unstable. Enemies and hazards were very simple, with no real surprises or advanced patterns. The level design was straightforward and easy to clear.

Codex nailed the fundamentals but didn’t really “go above and beyond” the prompt. It delivered a working game, not a memorable one.

Here’s how Codex scored:

• Runs first try: 9/10 (auto-fixed its own issues)
• Jump feel: 8.5/10
• Collision: 8/10
• Camera: 6/10 (shaky and distracting)
• Enemies: 6/10 (very basic)
• Coins: 7/10
• Hazards & lives: 7/10
• Win/lose states: 6/10
• Visual polish: 5–6/10 (rated as 6)
• Wow factor: 4/10 (lowest of all three)

Final score for GPT‑5.5 Codex: 67.5/100.

If you’re interested in how Codex compares to other models in more technical scenarios, there’s a deeper breakdown in this Blender-focused Opus vs GPT‑5.5 Codex test.

Claude Fable 5: the surprise all-round winner

The newest model in the lineup, Claude Fable 5, turned out to be the clear winner—by a wide margin.

Fable did something neither Opus nor Codex did: it automatically invoked a dedicated “front-end design” skill and structured its own plan into clear parts, including proper player physics, rendering, and visual effects. That planning showed up in the final game.

The finished platformer looked clean and modern, with smooth motion and a nice hovering visual effect over the whole scene. The character design was playful, and the overall presentation felt more refined than Codex and more lively than Opus.

Gameplay-wise, Fable added touches the others missed:

• Springs that launched the player upward
• Well-placed coins with subtle animations
• Enemies and traps at multiple heights
• A more challenging layout that demanded careful timing

The difficulty curve was noticeably better. Some jumps and enemy arrangements were genuinely tricky, which made the level feel more like a real game and less like a simple demo.

The main downside was the camera: it moved up and down with the player, sometimes making it hard to see what was below. Hazards also didn’t always behave perfectly—spikes didn’t consistently cost a life the way they were supposed to.

Even with those flaws, Fable delivered the most complete experience:

• Runs first try: 9/10
• Jump feel: 9/10
• Collision: 9/10
• Camera: 8/10 (good, but a bit floaty)
• Enemies: 8/10
• Coins: 8/10
• Hazards & lives: 6/10 (inconsistent spike behavior)
• Win/lose states: 10/10
• Visual polish: 9/10
• Wow factor: 9/10 (springs, animations, overall juice)

Final score for Claude Fable 5: 85/100.

Side-by-side scores: where each model shines

Putting the three final scores together gives a clear picture:

• Claude Fable 5: 85/100
• Claude Opus 4.8: 75/100
• GPT‑5.5 Codex: 67.5/100

Looking at the breakdown, two rows tell most of the story:

Runs first try
• Fable: 9
• Opus: 6
• Codex: 9

Codex and Fable both delivered working games on the first attempt. Opus needed a second pass to fix unreachable platforms, which cost it heavily.

Wow factor
• Fable: 9
• Opus: 6
• Codex: 4

This is where the models really separated. All three were explicitly told to add music, particles, and surprises. Fable clearly took that instruction the furthest, Opus added a bit of flair, and Codex mostly stayed at the bare minimum.

What this tells us about these AI models

Even though this was “just” a platformer test, it reveals a lot about how these models behave on creative coding tasks.

GPT‑5.5 Codex is excellent when you need something that simply works. Its self-testing loop is a big advantage for reliability and debugging. But if you want creativity and extra polish without micromanaging it, Codex may under-deliver unless you push it with more detailed prompts.

Claude Opus 4.8 feels like a strong all-rounder. When it runs, it produces polished, well-structured output with good camera work and solid game feel. However, it’s more prone to needing a follow-up pass to fix level design or edge cases. In more complex comparisons, like this broader GPT‑5.5 vs Claude Opus benchmark, that same pattern shows up: high quality, but sometimes a bit fragile on first run.

Claude Fable 5 stands out as the most “ambitious” model in this test. It not only met the requirements but also leaned into the “surprise me” part of the prompt with better level design, extra mechanics like springs, and stronger visual polish. For creative coding tasks where you want both functionality and flair, Fable looks especially promising.

Which model should you use for game-like projects?

Based on this test:

• Choose GPT‑5.5 Codex if you care most about a working prototype with strong debugging and are comfortable adding your own creative polish afterward.

• Choose Claude Opus 4.8 if you want a balanced model that can produce polished experiences, as long as you’re willing to give it at least one round of feedback to fix rough edges.

• Choose Claude Fable 5 if you want the AI to handle both the code and much of the game feel—visuals, difficulty, and extra mechanics—with minimal back-and-forth.

As these models evolve, tests like this are becoming one of the best ways to understand their real strengths: not just how they perform on benchmarks, but how they behave when you ask them to build something end-to-end.