I made Fable 5 and Opus 4.8 build the same apps: here’s what happened

What happens when you give two of Anthropic’s most powerful models, Fable 5 and Opus 4.8, the exact same prompts and ask them to ship real apps in a single shot? In this head-to-head test, both models were tasked with building three ambitious projects: a production-quality e-commerce store, an interactive 3D art history museum, and a fully playable Age of Empires–style RTS game. Same rules, same constraints, deployed live—no revisions.

The result: both models are strong, but Fable 5 consistently pulled ahead, especially in design quality, 3D experiences, and game building.

Test setup: one-shot builds under real constraints

Each build followed the same structure. The prompt was sent once to each model (Fable 5 on the left, Opus 4.8 on the right) inside a coding environment. The models had to:

• Architect the app end-to-end (frontend, backend, data, and integrations where needed).
• Generate all code and assets in a single run, with no iterative debugging or manual fixes.
• Produce something that runs live in the browser and feels like a real product or game.

A custom usage tracker monitored input/output tokens, estimated cost under usage-based pricing, and total build time. That made it possible to compare not just quality, but also speed and efficiency.

Build #1: a full e-commerce store for “Slow Burn”

The first challenge was a complete e-commerce site for a fictional candle brand called Slow Burn. The requirements were intentionally demanding:

• Production-quality design, similar to a modern Shopify store.
• 30 distinct products with clearly different images.
• All text readable (no low-contrast typography).
• Clear product labeling, categories, and a working cart.

Opus 4.8: functional but rough around the edges

Opus 4.8 produced a working store with a hero section, product grid, categories, and cart drawer. Compared to earlier dynamic workflow tests, it was a clear improvement: product labels were present, images were more coherent, and the site was fully navigable.

However, several UX and design issues stood out:

• The hero image overlapped text, making the headline harder to read.
• Some typography and section colors felt off and visually noisy.
• The category filters were cluttered and unintuitive, with too many oddly grouped options.
• The navbar behavior was confusing, and certain UI elements (like the cart icon) were visually ambiguous.

From a pure functionality standpoint, Opus 4.8 delivered a usable store. But it felt more like a decent starter template than a polished, brand-ready e-commerce experience.

Fable 5: a cleaner, more polished storefront

Fable 5’s version of Slow Burn immediately felt closer to a real Shopify theme. It added thoughtful touches without being explicitly instructed to:

• A clean, readable hero with strong CTAs and a subtle gradient background.
• A top notification bar (e.g., shipping or promo banner), a staple of modern e-commerce.
• Well-designed buttons and typography that matched the brand mood.
• A “shop by ritual” section (morning, deep work, unwind, sleep) that doubled as intuitive filters.

Where Fable 5 really shined was image prompting. Using GPT Image 2 behind the scenes, it generated candle photos that looked like real studio shots—consistent lighting, textured backgrounds, branches and shadows, and colors that matched the label and surrounding UI. The product grid felt cohesive and intentional, not random.

Overall, Fable 5’s store looked and behaved much more like a production-ready DTC brand site, with better filtering, layout, and visual hierarchy.

Cost and speed for the e-commerce build

For the e-commerce store:

• Opus 4.8 used ~198k output tokens (around $21.41 equivalent).
• Fable 5 used ~188k output tokens (around $36.84 equivalent).

Fable 5 was more token-efficient but more expensive per token. In terms of time, Fable 5 finished in roughly 35 minutes, while Opus 4.8 took closer to 50 minutes. For a full e-commerce build, both costs are in the ballpark of a month of a Shopify subscription—but Fable 5 delivered a noticeably better result, faster.

Build #2: an interactive 3D art history museum

The second challenge was far more complex: a browser-based 3D museum of art history. The idea was to replace static textbooks and Wikipedia rabbit holes with an immersive experience where you can:

• Explore a zoomable timeline of major art periods (Renaissance, Baroque, Impressionism, etc.).
• Click into specific artists to see a museum-style placard and biography.
• Walk through realistic 3D galleries of their works, pulled from Wikimedia Commons.
• Back the whole thing with a real database (Neon) storing periods, artists, and hundreds of paintings.

The prompt explicitly banned “lazy 3JS demos” and demanded realistic lighting, shading, and tone mapping.

Data and copyright constraints

Both models had to deal with Wikimedia/Wikipedia data. Opus 4.8 flagged copyright issues for modern artists like Picasso and Dalí and refused to pull non–public domain images. Fable 5 also acknowledged the constraint but proceeded by focusing on public-domain-friendly content.

Fable 5 showed strong agentic behavior here. It:

• Spawned multiple agents to fetch and normalize data from Wikipedia/Wikimedia.
• Stored everything in Neon, ending up with 16 art periods, 69 artists, and 767 paintings.
• Detected subtle data issues, such as misparsed article titles like “Francis Bacon (artist)” vs other Francis Bacons, and corrected category names accordingly.

This kind of needle-in-a-haystack debugging—spotting and fixing schema issues across hundreds of entries—highlighted Fable 5’s strength as an orchestrator of parallel agents, something explored in more depth in this week-long Fable 5 test.

Opus 4.8: promising timeline, broken interaction

Opus 4.8 produced a visually interesting timeline view. Periods were color-coded, with overlapping bands for things like Early Renaissance and Northern Renaissance. Zooming in on the canvas worked, and artists would pop into view as you moved around.

But the interaction broke down at the most important step: clicking into artists. The canvas panning and zoom layer intercepted clicks, so it was impossible to enter any galleries. The timeline looked promising, but the core experience—walking through a 3D museum of paintings—was unreachable.

There were also alternative views (cosmos-like layouts of movements and artists), but they felt messy and less usable. Structurally, this was still one of the better attempts at this kind of app from an LLM, yet it stopped short of delivering the full vision.

Fable 5: a beautiful infinite canvas and real 3D galleries

Fable 5’s version took the same concept and executed it with far more polish.

On the timeline side, it built an infinite canvas with an astrological-style motif: art periods and artists appeared as stars and nodes. As you zoomed out, artists collapsed into dots; as you zoomed in, names and connections appeared cleanly, without the overlapping chaos seen in Opus 4.8’s version. The zoom and pan felt smooth and deliberate.

Clicking an artist (for example, Degas) triggered a nice GSAP-powered animation and opened an artist detail view with biography and context. From there, you could enter a full 3D gallery.

Inside the gallery, the experience finally matched the original vision:

• A walkable 3D space, navigable with keyboard and mouse.
• Paintings from Wikipedia/Wikimedia hung on the walls in a realistic layout.
• Lighting, shadows, and camera controls made it feel like a real museum room.
• Clicking a painting opened more information, turning the gallery into an interactive learning tool.

Fable 5 even self-critiqued design details mid-build (“the pitch black floor bothers me, let me adjust the lighting”), then iterated on its own output. That kind of opinionated design feedback is rare in current models.

Cost and speed for the 3D museum

For the art museum build:

• Opus 4.8 used ~51k input and 437k output tokens (about $46 equivalent).
• Fable 5 used ~54k input and 280k output tokens (about $37 equivalent), despite doing more with agents and data.

Fable 5 again finished significantly faster—around 30 minutes versus Opus 4.8’s 40+ minutes—and was more token-efficient overall. Under upcoming usage-based pricing, a build like this could cost in the $60+ range, which is steep for a one-off experiment but impressive for a fully architected, data-backed 3D experience.

Build #3: an Age of Empires–style RTS in the browser

The final test was the most ambitious: a fully playable real-time strategy game inspired by Age of Empires, running in the browser with 3D graphics.

The requirements included:

• A full 3D world using Three.js or a WebGL equivalent.
• A town center to start from, plus buildings, units, and enemies.
• Camera movement, selection, and basic RTS controls (left-click select, right-click move/attack).
• Lighting and visuals that feel like a real, if simplified, RTS game.

Opus 4.8: broken gameplay and unfinished feel

Opus 4.8 generated a 3D scene with some basic shapes and UI elements, but the experience fell apart quickly:

• The graphics were crude, more like blobs than recognizable buildings or units.
• Camera movement and zoom were either missing or non-functional.
• Core interactions like selecting units, building structures, or moving around the map didn’t work reliably.

In practice, the app felt broken. Without working camera controls and a clear gameplay loop, it couldn’t be considered a playable RTS.

Fable 5: a surprisingly convincing RTS prototype

Fable 5’s game, titled “Empires of Dawn,” looked and felt dramatically closer to an actual Age of Empires–style RTS.

When the game loaded, it presented clear instructions (left-click to select, right-click to command) and a fully navigable 3D map. The visuals were striking:

• A detailed terrain with trees, resources, and structures.
• A recognizable town center, houses, farms, and enemy base.
• Units with visible armor and clear silhouettes.

Camera panning and zoom worked smoothly, and the core loop was in place: select villagers, place buildings like houses and farms, and interact with enemy units and structures. Resource constraints were implemented (e.g., “not enough resources” messages), hinting at a deeper economy system.

Even without mastering the full strategy, it was obvious that the game was not just a tech demo—it was a legitimately playable RTS prototype, built in about half an hour by a single model.

Overall verdict: Fable 5 vs Opus 4.8

Across all three builds—e-commerce store, 3D art museum, and RTS game—Fable 5 consistently outperformed Opus 4.8 in several key areas:

• Design and UX: Fable 5’s outputs looked more like real products: better layouts, typography, navigation, and micro-interactions.
• 3D and graphics: From the art museum galleries to the RTS world, Fable 5 delivered far more realistic and polished 3D scenes.
• Agent orchestration: It coordinated multiple agents, debugged data issues, and self-critiqued design choices mid-build.
• Speed and efficiency: In these tests, Fable 5 was often 15–20 minutes faster than Opus 4.8 while using fewer output tokens for more complex behavior.

Opus 4.8 still showed strong reasoning and produced some of the best single-shot attempts seen so far for complex apps, especially in data organization and timelines. For a deeper dive into where Opus 4.8 shines, it’s worth reading this overview of Claude Opus 4.8. But in this particular head-to-head, Fable 5 set a new bar for what an AI model can build in one shot—especially in visually rich, interactive experiences.

What this means for builders

If you’re using AI as a coding partner, these tests highlight a few practical takeaways:

• For 3D, games, and highly visual apps, Fable 5 currently looks like the stronger choice.
• For production-quality frontends, Fable 5’s design instincts and image prompting can save a lot of manual polish.
• Opus 4.8 remains a powerful option for reasoning-heavy tasks and complex architectures, especially when paired with tools like Ultra Code and dynamic workflows.

As usage-based pricing rolls out, cost will matter more—but so will quality per dollar and time saved. These builds suggest that paying a bit more for Fable 5 can be justified when you need high-end UX, 3D, or game-like interactions out of the box.

Either way, the bar for what a single AI call can ship has just moved again. If this is what one-shot builds look like today, the next few months of AI-native apps are going to be very interesting.