I Made Fable 5 and Opus 4.8 Each Build Minecraft From Scratch. The Gap Wasn’t in the Code

A developer tested Fable 5 and Opus 4.8 by having each build a Minecraft-style voxel game from scratch, finding that both produced working code but Fable 5 required significantly less user guidance and performed more autonomous reasoning during the process.

I gave two of the strongest AI coding models the same job, build me a 3D Minecraft-style voxel game, and let each one run. On paper Fable 5 sits above Opus 4.8, so I expected the gap to show up as better code or a more polished result. That’s not really where it showed up. The difference that actually mattered was how little I had to say to get there, and how much of the thinking each model did on its own. Here’s what I found, and why it changed how I think about what separates these models. I wanted to test something that benchmarks do not capture well. Coding leaderboards rank models on how good the output is, pass rates, bug counts, benchmark scores. But when you actually build something with an AI model, a lot of the experience is not about the final code quality at all. It’s about how much effort you have to put in to get there, how much you have to spell out, how often you have to correct course, and how much the model figures out on its own without being told. So I gave the same task to two of the best coding models available, Fable 5 and Opus 4.8, and paid attention to that side of it. The task was deliberately open-ended, build a 3D Minecraft-style game, a first-person world made of blocks you can place and break, with terrain to walk around in. This is a genuinely demanding thing to ask, because a blocky voxel game isn’t one problem, it’s a stack of them, generating a 3D world out of blocks, rendering it efficiently so it does not crawl, handling a first-person camera and movement, detecting which block you are looking at, and letting you add and remove blocks without the whole thing falling apart. It’s exactly the kind of multi-part build where the difference between models tends to show up. One important detail about when I did this, because it matters for whether the comparison is even valid. I ran this build before Fable 5 had its automatic rerouting behavior, back when Fable 5 was simply Fable 5 start to finish. Today, Fable 5 includes a safety layer that can quietly hand certain requests off to Opus 4.8 in the middle of a session, which would muddy any head-to-head, because part of your Fable session might secretly be an Opus session. When I built this, that was not a factor. What I was using was pure Fable 5 against pure Opus 4.8, which is exactly why I trust what I saw. Here’s what I expected, and here’s what actually happened. Going in, I assumed the story would be about output quality. Fable 5 ranks at the top of the coding charts, above Opus 4.8, so my mental model was simple, Fable would produce better, cleaner, more correct code, and Opus would produce good-but-slightly-worse code. I expected to be comparing the artifacts, whose world looked better, whose code had fewer bugs, whose game ran more smoothly. That framing turned out to miss the point, because both models are genuinely capable. Both of them could build a working voxel game. Both produced code that ran. If I’d only looked at the end result of a fully specified, hand-held session, I might have concluded they were roughly equivalent, because at the level of “can it produce working voxel-game code,” they both can. The benchmark-shaped expectation, that this was a contest of output quality, isn’t where the real difference lived. The difference lived in the process. And it was bigger than I expected. The thing that genuinely separated the two, in my experience, was how much I had to say to get a good result, and how much reasoning each model did without me. With Opus 4.8, I got a good voxel game, but I had to drive. When I asked for something, it did what I asked, well, but it tended to do the thing I literally said and then wait. If I asked for block placement, I got block placement, and then I needed to think of the next thing, the fact that placement should probably have a visual highlight on the targeted block, that breaking blocks should feel responsive, that the world needed sensible boundaries. I was the one holding the mental model of what a good voxel game needs, and I was feeding it to the model piece by piece. It was a capable executor of my instructions. With Fable 5, I found myself saying much less. I would describe what I wanted at a higher level, and it would fill in the details I hadn’t mentioned, often the exact details I’d have gotten to eventually. When I asked for the ability to place and break blocks, it added the targeting highlight without me asking, because obviously a voxel game needs to show you which block you are aiming at. It anticipated the next problem before I raised it. It handled the reasoning about what the game needed, not just the reasoning about how to code the specific thing I requested. I was describing intent, and it was handling both the intent and the implications. That’s the attention to detail I didn’t expect to be the headline. It wasn’t that Fable’s code was dramatically prettier. It was that Fable seemed to understand what I was actually trying to build, the whole thing, and filled in the connective tissue on its own, while Opus needed me to specify that connective tissue myself. The gap was in initiative and inference, not in raw output polish. Here’s why that surprised me, and why I think it is the more important axis. When people compare AI coding models, they almost always compare the output. But if you’ve ever actually built something non-trivial with one of these models, you know that the real cost is not the model’s occasional mistake, it is the mental load of specifying everything, catching what the model missed, and steering it through all the parts of the problem it did not think to handle. A model that produces 95-percent-perfect code but makes you hold the entire design in your head is, in practice, more tiring to work with than a model that produces slightly less perfect code but shares the cognitive load, that notices the thing you forgot, that reasons about the whole problem rather than just the sentence you typed. The second model feels less like a tool you operate and more like a collaborator who gets it. That’s what Fable 5 felt like on this build, and it is a difference that a coding benchmark, which scores the final code against a fixed spec, structurally can’t measure. The benchmark hands the model the full specification. Real building is largely about who generates the specification, and that’s exactly where the two models differed most. None of this means Opus 4.8 is a weak model. It’s genuinely strong, and for a task where I want tight control and I am specifying everything precisely anyway, its execute-exactly-what-I-said behavior is arguably a feature, not a limitation. There are workflows where you want the model to do what you said and nothing more. But for an open-ended creative build, where half the work is figuring out what the thing even needs, the model that does more of that figuring is the one that changes the experience. A few things worth stating plainly, so this lands as an honest account and not a hype piece. This was one build, of one type of game, by one person. It’s a real observation, but it’s not a controlled benchmark, and your experience on a different kind of task could differ. Attention to detail and initiative are also somewhat subjective, they’re exactly the qualities that are hard to measure and easy to perceive differently, so treat this as one developer’s genuine impression rather than a definitive ruling. It is also worth repeating, if you go to try this yourself, that a clean comparison is harder to set up now than it was when I built this, because of the rerouting behavior I mentioned earlier. Part of your Fable session may quietly become an Opus session, so if you want to compare the two deliberately, you have to account for that. I had the benefit of testing them before that existed. And the usual disclaimer about benchmarks cuts both ways here. I’m not saying the coding leaderboards are wrong, Fable ranking above Opus on code quality may be perfectly accurate. I’m saying that ranking measured one thing, and the thing I actually felt building with them was something else the ranking doesn’t capture. Both can be true. The lesson I walked away with is that the most important difference between two strong coding models might not be the one the benchmarks measure. I went in expecting to compare output and came out realizing the output was the least interesting part, because both models could produce a working game. What separated them was how much of the thinking I had to do, and how much they did for me. For choosing a model, that reframes the question. Instead of only asking which model writes better code, it’s worth asking which model better understands what you are trying to build, because on a real, open-ended project that second quality is what determines whether the experience feels like operating a tool or working with a collaborator. On my voxel game, Fable 5 did more of the understanding, and that, far more than any difference in the code itself, was what I did not expect and what I will remember. If you build with these models, I’d genuinely like to know whether you have seen the same thing, the higher-ranked model needing less hand-holding, or whether your experience points the other way. That’s the kind of difference we should be comparing, and it is the kind that no leaderboard will tell you. This is one developer’s hands-on experience, not a controlled benchmark. Model behavior varies by task, and access to these models continues to change. Try your own build before drawing conclusions. I Made Fable 5 and Opus 4.8 Each Build Minecraft From Scratch. The Gap Wasn’t in the Code https://pub.towardsai.net/i-made-fable-5-and-opus-4-8-each-build-minecraft-from-scratch-the-gap-wasnt-in-the-code-19483fc8a215 was originally published in Towards AI https://pub.towardsai.net on Medium, where people are continuing the conversation by highlighting and responding to this story.