Battle of the AI Lamps: Fable 5.1 vs GPT-6 Astra — Which One Should I Rub?

林政賢 · 2026-09-04

There are two stalls in the market, each selling a magic lamp. You are standing between them, wallet in hand, with one very unglamorous but very practical question on your mind: which one should I rub?

Then this week, within two days, both stallholders brought out a new one.

September 1st, Anthropic released Claude Fable 5.1. September 3rd, OpenAI released GPT-6 Astra. Two days apart — faster than a bubble tea chain launches a new drink.

And this is no longer the old rhythm of a small update every quarter and a big one every year. These days you open your phone every morning to news of another model. The name you finally memorised yesterday has grown a decimal point today. You cannot keep up. Nobody can.

So this piece is not going to help you keep up. It answers that unglamorous question instead: I want to start building something next month — which card do I put it on?

But before that, there is something every comparison article skips — one of these new lamps ships with a rather strange warning on the label.

My position up front: I use Claude. This article is biased and I am telling you so.
But below I go out of my way to spell out where the other side beats mine — especially the one thing that matters most if you have not started yet.

First, what rubbing a lamp actually feels like

Skip this section if you already know what vibe coding is.

Writing software the traditional way means learning syntax, then frameworks, then a pile of things you do not care about, before you can make anything that moves. Like needing a licence before you are allowed to light the lamp.

Vibe coding is you just saying it.

"I want a page with three cards on it that lift up when the mouse moves over them" — you type that, and it writes the code. You look at the screen and say "the cards are too big", "I don't like that colour", "clicking here does nothing", and it changes them.

You are not writing code. You are making a wish, and then complaining.

Three years ago this did not exist. Two years ago it was terrible. This year it genuinely works. So the only question left is which lamp to rub.

The new lamp sometimes goes out on its own

Let's start with GPT-6 Astra, because it is the biggest news of the week and its story is unusual.

OpenAI say this is the first model of theirs to reach their internal "Critical" cybersecurity threshold — because it developed working exploits against hardened browsers and operating systems, and found two previously unknown V8 vulnerabilities.

In plain language: it is strong enough that it startled the people who built it.

You can buy it normally. It went to a limited set of organisations on September 3rd, then within days to all ChatGPT Plus, Pro, Business and Enterprise users, with the API and the cloud platforms alongside; it is already inside Codex, and usage counts against the subscription allowance you already pay for. So all those hands-on tests you have been seeing this week are perfectly normal.

The strange part comes next.

⚠ THE LINE ON THE LABEL

Because of that threshold, the public version refuses advanced offensive security work. Which is entirely reasonable — most people will never go anywhere near it.

But OpenAI's safety lead added something else: users outside the trusted-access programmes may run into slowdowns, pauses or blocks — and "sometimes during unrelated work".

For API developers it is blunter still: when the safety check fires, it terminates the task outright rather than pausing to ask you.

Translated back into lamp terms: this lamp burns very bright, but every so often it goes out halfway through your wish — and not necessarily because of anything you wished for.

I am not saying the safety design is wrong. Something that can find browser vulnerabilities on its own ought to have a brake. What I am saying is this:

No benchmark table
tells you about that.

And that is this article's answer. Because it forces into view something the scoreboards usually cover up — you were never buying the model.

What you buy is not the genie, it's the car

Every comparison online is comparing models: Fable 5.1 scored this, Astra scored that.

But what you actually touch is not the model, it is the tool. Roughly the difference between an engine and a car.

ENGINEThe model (Fable 5.1, GPT-6 Astra)

Does the thinking. This is what benchmarks measure. But you never touch it directly — and you would not put up with an engine that occasionally cuts out on the motorway just because its horsepower figure is impressive.

CARThe tool (Claude Code, Codex)

Does the doing. It reads the files on your machine, actually edits the code, runs it to see whether anything broke, and goes back to fix what did. This is the thing you use every day.

A good car with an ordinary engine usually drives better than a great engine bolted into a bad car. And "does it cut out halfway" is not a column on any scoreboard.

So the real question is not "Fable or Astra", it is "Claude Code or Codex". That is the question the rest of this article answers.

The two price lists

Start with a coincidence most people missed: the two flagships cost exactly the same over the API.

API PRICE (PER MILLION TOKENS)

$10 / $50Claude Fable 5.1 (input / output), cached reads $0.25

$10 / $50GPT-6 Astra (input / output), cached reads $1.00

Context: Fable 5.1 holds one million tokens, Astra 1.05 million; both cap output at 128K. Astra adds one rule: past 272K tokens of input in a single request, input is billed at double and output at 1.5×.

Same list price. The difference hides in two places.

The first is caching — the discount rate for re-reading the same material. The number looks small, but when you are using AI to change code it re-reads your whole project on every single round, so the cached rate is where most of your actual bill lives. $0.25 against $1. Four times.

The second is that 272K line. Once a project grows, you hit it easily, and the bill quietly doubles without saying anything.

Before going further though, I should say: most people will never touch any of these numbers.

Because what you'll actually be paying is a subscription

The API is for engineers wiring the model into their own software. What you want to do is sit down and talk to it — and for that you pay monthly.

OPENAI (CODEX LIVES IN HERE)

$0Free tier, with strict usage limits

$8Go

$20Plus

$100/$200Pro (5× and 20× the usage)

ANTHROPIC (CLAUDE CODE LIVES IN HERE)

—No free tier

$20Pro (the cheapest way in)

$100/$200Max (5× and 20× the usage)

I use Claude, but I have to be honest about this one: asking someone who has not yet decided whether they care to hand over twenty dollars first is an unnecessary barrier. If you just want to poke at it, the stall on the right lets you start without paying.

But nobody tells you how many rubs twenty dollars buys

This is the part I most wanted to write, because every comparison article prints the price list and none of them tell you how long the lamp actually lasts.

⚠ BRACE YOURSELF

On the $20 plan, usage is metered in five-hour windows.

And in my experience: simply scaffolding one project burns through that window in under an hour. Then the lamp goes dark and you sit there waiting for it to come back on.

The free tier all the more so. It is enough to let you touch the thing. It is not enough to let you finish anything.

I am on the top plan myself — Max ×20 ($200) — and I simultaneously run a $200 plan on another platform.

Why both? Because I have five or six projects running at the same time. (How that is done, how I split attention, and how I avoid losing my mind — that is a separate article.)

I am not telling you this to show off what I spend. Quite the opposite — I want you neither scared off at step one, nor sprinting at step one.

So here is the right order

Do not open with "which plan is best value". You do not yet know how much you need.

STEP 1Use the free tier to build something tiny

As small as it can possibly be. A calculator, a page that logs something, a thing that turns text into a table. The goal is not to build something good. It is to answer one question: does this excite me, or does it irritate me?

STEP 2Only pay the $20 once you find it interesting

Make that ugly thing look good and work well. This is when you first hit the five-hour wall — and that feeling of being cut off mid-flow is itself a signal.

STEP 3Then you'll discover the $100 tier yourself

Not because an article told you to upgrade, but because you now have something you genuinely want to finish, and waiting for the reset has become your biggest obstacle. That need grew out of you. Nobody sold it to you.

STEP 4Only then the $200, running five or six projects at once

By this point that money is no longer a learning cost. It is the cost of a production tool. And you buy a production tool based on what it earns back, not on what it costs.

Of course, you may well discover at the free-tier stage that this simply is not for you.
That is also a result — and the cheapest one you will ever buy.

Where each car is stronger

Where Claude Code is stronger

Code quality, and wide-reaching changes — the kind of task where one feature touches a dozen files.

Plainly: it is less likely to break B while fixing A. Once a project grows and things start depending on each other, the value of that rises fast.

Where Codex is stronger

Speed, running a whole task to completion on its own, and a free tier you can try first.

Plainly: hand it the job, go make a coffee, come back to a result. Especially good for the repetitive work where the rules are clear.

Plenty of people who have been at this a while rub both lamps — not out of indecision, but because the two are genuinely good at different things. You did not throw away the screwdriver when you bought a drill.

So what about the benchmarks? I checked, and hit three problems

I meant to give you a clean comparison table. Having done the checking, I decided not to — because that table would mislead you.

Here are the three things I actually ran into.

⚠ WHY YOU CAN'T READ THOSE TABLES STRAIGHT

One: same name, different exam paper. Both published an "OSWorld" score — Fable 5.1 at 77.9%, Astra at 72.6%. Looks comparable. But one ran version 2.0 and the other ran V2-Offline. Those are two different exams, and subtracting one from the other means nothing.

Two: the same figure came back two different ways. For Astra's DeepSWE result alone, different sources gave me 74.1% and 78.9%. I have no way to judge which is right, so I am using neither.

Three: almost all of it is vendor-run. That is industry practice and both sides do it. But a vendor's published score is the vendor's chosen questions, run on the vendor's tuned setup.

It is like the photo a stallholder hangs above the stall. The photo is real and the lamp is real, but that is the angle the owner picked and the one lamp he polished hardest. What you take home is another matter.

The one number I do think is worth remembering is not about who won:

Astra scored 100% on ExploitBench. That is an exam specifically about finding and exploiting vulnerabilities. Full marks. And that is exactly why it comes with a brake.

Which is one way to understand this generation of the race: they are now strong enough that the strength itself has become a problem to manage.

But in Aladdin, the hard part was never finding the lamp

Everything so far has been lamp specifications. Price, brightness, how long it lasts, whose sign is prettier, which one cuts out on you.

And that is precisely my point: none of it is what matters.

Think back to Aladdin. The difficult part was never finding the lamp. The difficult part was the person doing the wishing.

Those stories share a setting people rarely notice: the genie is extremely obedient, and grants your wish literally. You say "I want to be rich" and it may well make you rich, in a way you never imagined and do not particularly want. It never asks "are you sure?" It says "of course", and gets to work.

If you have used AI, this will feel familiar.

You say "make this button a bit smaller"; it does, and shifts three neighbouring things while it is there. You say "add a search function"; it does, beautifully, except it cannot find the kind of thing you actually wanted to search for. Every time, it sounds certain. Every time, it says it is done.

It means no harm. It is simply doing what you literally said — and between what is in your head and what comes out of your mouth there is always a gap.

And every wish carries an invisible side effect

This is where those stories get genuinely sinister.

You wish to be rich, and the money really arrives — along with everything you did not wish for: never quite trusting who means it, relationships that used to be simple now carrying arithmetic.

You wish to be beautiful, and that comes true too — along with the spotlight, along with being looked at, along with never leaving the house bare-faced again. The genie did not lie to you. It granted the half you said out loud. The other half grew by itself.

AI is exactly like this right now.

You ask for one thing, it delivers (or it doesn't), and in the same motion it touches a pile of places you cannot see from where you are standing. The screen looks right, but the behaviour in some corner has quietly changed; this page is fixed and something on another page has broken, and you find out three days later.

So you go back and debug, again and again. That is not the thing being broken. That is the side effect of the wish.

And one more thing anyone who has really used it for a while knows: the longer the conversation, the more it starts making things up.

⚠ LONGER CONTEXT, MORE HALLUCINATION

Once a single conversation runs long, it starts misremembering things it was told earlier, citing a setting that does not exist, and explaining — very earnestly — something it invented itself.

This has been improving for years; both flagships in this generation now hold over a million tokens of context, and the frequency has clearly dropped. But right now, it is still there.

So the real threshold in the whole story is this:
you have to know what you want, and be able to see when it hands you the wrong thing.

And that is exactly why now is when you should step in

I do not think these problems are permanent. The barrier is dropping, and dropping fast — a few more iterations, a few more years, and hallucination will probably be rare enough that you barely meet it, with the side effects caught before they reach you.

But you cannot wait for that day to arrive.

Because it is precisely while it still gets things wrong that your experience has a price. Once it really stops getting things wrong, "being able to see what's off" stops being worth anything too.

Put another way: this stretch of time while it is still fallible is not a reason to stay away. It is your window.

And the other name for a window is timing. While it is still open, go and find your window, and your lamp.

"AI makes mistakes" is common knowledge by now; you do not need a tenth article telling you it hallucinates. What nobody has spelled out is the next sentence: so who is going to notice that it got it wrong?

The people who can tell are running on experience

The answer is not glamorous, but it is solid: on the things you have actually lived through.

Someone who has worked in food service can see at a glance that an ordering flow will jam at peak hour, because they have stood in that spot. Someone who has raised a child can see at a glance that a confirm button sits too easily under a thumb, because it has been jabbed at random. These are not facts. They are marks left on you.

AI carries no marks. It can recite every restaurant workflow on earth to you, but it has never fumbled through the moment the crowd came in.

Which is why it always sounds so sure. It is not lying to you. It simply has nothing that would make it hesitate.

Which lamp you pick decides how efficiently you wish.
The quality of the wish can only be you.

Which is also why I think you should not be anxious about version numbers. Two new lamps in two days this week, one of which cuts out on you; next month someone will tell you those are old news. The shelf life of those figures is far shorter than you think.

But the instincts in you that say "I just know that's not right" do not expire. In fact they appreciate as the barrier falls — because when everyone is holding a lamp, the scarce thing is no longer the lamp. It is knowing what to wish for.

If you think visually, don't assume you're at a disadvantage

People who do design, images or content often assume this has nothing to do with them. The opposite is true.

You can say "the spacing here is too tight and the shadow is too heavy, so it looks like it's floating" — AI understands that completely and can act on it. A hundred times more useful than "it looks a bit off".

The eye you assumed had nothing to do with programming is the easiest part to plug straight in. (I have written about this more fully in another piece, including how I went from an image-maker who could not code at all to someone who ships an App.)

So, if you're starting today

The order is simple:

Build something tiny on the free tier → pay $20 to refine it if it grabs you → you'll find the $100 need yourself → and only then $200

But before rubbing any lamp, do something more important: write the thing you want to build as three sentences.

They do not have to be elegant, and never mind whether it is technically possible. Just write: who it is for, what nuisance it removes, and how it differs from how that is done today.

If you can write those, you are already better prepared than most people. Because the lamps in the market will keep changing — next year there will be brighter ones, cheaper ones, ones with flashier signs, and even ones you cannot buy at all.

But there is only one person doing the wishing, and that one cannot be swapped out.

COURSE

I'll teach how to wish, in person

However carefully an article is written, it cannot match sitting beside you, watching you work, and telling you on the spot what this sentence will be understood to mean. I'll be running a course covering this whole hard-won workflow face to face — how to ask, how to tell when it's bluffing, and how to turn your own experience into something that runs. Follow and subscribe, and you'll hear the moment it opens.

Courses & updates →

OPEN SOURCE

Nine packages we built, all free

The problems we solved while building things got pulled out and open-sourced. A scroll-driven frame-sequence player, CJK PDFs that don't come out as tofu boxes, mobile audio, real-time multiplayer rooms with no game server — every one of them grew out of a hole we actually fell into.

scroll-frame-sequencecomfy-toolkitcomfy-lintedge-roomscapacitor-web-shimweb-audio-kitgrow-only-syncreact-job-trackercjk-pdf

See all open-source projects →

WHY I WRITE THIS BLOG

I am not trying to turn everyone into an engineer. I want more people willing to reach out and touch AI, and then use it to live a slightly better life — one more income stream, a little less overtime, and the idea you have been sitting on for years finally made real. The technology is a tool passing through; the "better life" is the point. (And of course, if you happen to like the App we made, a subscription would make me very happy.)