Dreaming about AI Architects — Then Claude Fable 5 Dropped

I had a dream last week.

Not the kind where you’re falling or your teeth crumble. The kind that stays with you after your eyes open and you stare at the ceiling, still trying to place yourself. In the dream, I was watching something being built. A structure — could’ve been software, could’ve been a city, the dream wasn’t specific about that — being assembled piece by piece by something I couldn’t quite see. Hands, but not hands. A presence in the middle of everything, working.

And I was standing at the end of the line. Not building. Not turning the screws or writing the lines. Just… watching. Verifying. Occasionally pointing — no, over there, that’s what we need — and the presence would adjust and keep building.

The odd thing was, I wasn’t useless. I was valuable in a way I hadn’t been before. My job wasn’t to construct. It was to know what to construct. To hold the vision. To decide what was worth building. The presence in the middle was doing all the work — but I was the one who knew what work mattered.

I woke up and wrote it down before it evaporated. Humans at the edges. Ideas in. Verification out. AI in the middle.

Then today happened.

Claude Fable 5 Dropped, and Suddenly the Dream Wasn’t Abstract Anymore

June 9, 2026. Anthropic released Claude Fable 5 — the first Mythos-class model the public can actually use. Not behind an enterprise gate. Not locked in a research lab. Available right now, through the API, through Claude Code, through the platform you already have open in another tab.

And the numbers aren’t incremental. They’re the kind you read twice because they don’t look real.

SWE-Bench Pro: 80.0%. For context, Opus 4.8 scored 69.2%. GPT 5.5 scored 58.6%. Fable 5 isn’t winning by a nose — it’s lapping the field.

But the benchmark number isn’t what got me. What got me was Stripe. Stripe used Fable 5 to modernise a 50-million-line Ruby codebase in one day. That’s a project their internal estimates pegged at two months for a full team. One day. One model. Fifty million lines of Ruby, rewritten.

Replit said “these are the strongest results of any Claude model we’ve ever tested.” Bubble said apps that took a hundred prompts a year ago now get one-shotted. Cursor said it opened up “a class of long-horizon problems that were out of reach for earlier models.”

The presence in the middle of the dream? It just got real.

Alex Finn’s Video Hit at the Same Time — and the Lesson Is the Same

Alex Finn dropped a video today too — Claude Fable 5 just dropped and I’m speechless — and inside of 13 minutes he demonstrated something that would’ve sounded like science fiction six months ago.

He built a fully working productivity app. Not a prototype. Not a “well, most of it works if you squint.” A complete web application with:

• To-do list
• Kanban board with drag-and-drop
• Calendar with day and week views, coloured events
• Note-taking app with daily journal entries
• Pomodoro timer with streaks, stats, and task attachment
• A Snake game for taking breaks

Built from one goal. Zero bugs. Everything worked.

And here’s the part that matters. Alex didn’t just type “build me a productivity app” and cross his fingers. He used what he called advanced plan mode — he told Claude his idea, then let Claude ask as many questions as it needed to fully understand what he wanted. Platform? Storage? Visual style? Integration depth? Note-taking approach? Pomodoro extras? Claude went round after round until the specification was comprehensive, and then it built.

Alex’s three tips — which, by the way, came directly from Anthropic:

1. Treat Claude as a thought partner — an equal collaborator, not a code monkey
2. Give Claude goals, not steps — point at the summit, don’t draw the trail
3. Be more ambitious — push past what you thought was the ceiling

Then he used /goal — a Claude Code feature that gives the model a specification with success criteria and tells it: don’t stop until this is done and verified. Claude then worked autonomously, checking periodically whether the goal was met, and didn’t stop until every checkbox was ticked.

The app named itself “Fable.” The UI was “colourful and playful” as requested. Alex thought it was a bit ugly — but it matched the spec. He got exactly what he asked for. The model didn’t guess wrong. It built what he described.

Here’s the shift Alex named that’s going to echo for a while:

Old way: “Is Claude doing the work right?” — you check for bugs, you test every step, you’re the QA department for a junior dev.

New way: “Is Claude doing the right work?” — the code comes out clean. The bugs aren’t the problem anymore. Now the only question is: did you point it at the right mountain?

The Human Job Is Changing — and That’s What My Dream Was About

Here’s what I keep coming back to. For the last two years, the AI conversation has been haunted by one question: what’s left for us?

If the model can code, what are developers for? If the model can write, what are writers for? If the model can design, what are designers for?

My dream had an answer. And Fable 5 makes it concrete.

The human job isn’t disappearing. It’s moving. We’re shifting from builders to architects. The work isn’t in the construction anymore — it’s in the conception. It’s in knowing what needs to exist, why it matters, who it serves, what success looks like.

This isn’t a demotion. It’s the promotion most of us have been asking for without realising it. How many hours have you lost debugging something that shouldn’t have been built in the first place? How many features have you shipped that nobody asked for because you were too deep in the implementation to question the premise?

If the AI can build flawlessly — and Fable 5’s benchmarks suggest we’re close to that — then the bottleneck shifts to the only thing AI can’t do: know what matters.

That’s where we become more valuable, not less. Ideas. Critical thinking. Taste. Judgment about what’s worth doing. The ability to sit with a problem and articulate exactly what success looks like, in enough detail that an AI can execute against it without guessing.

We are becoming architects of intent. The AI sits in the middle, doing the building. We sit at the edges — defining the vision at the start, verifying the result at the end.

This is exactly what Alex demonstrated. He didn’t write a line of code. He spent his energy on the only thing that couldn’t be automated: deciding what to build and describing it clearly.

The Two Weeks That Might Change Everything About Pricing

One thing that can’t go unmentioned: Fable 5 is free on subscriptions for exactly two weeks. Until June 22, it’s included in Pro, Max, Team, and Enterprise plans at no extra cost. After that? API-only, at $10 per million input tokens and $50 per million output tokens — double the price of Opus 4.8.

Alex called it “the beginning of the end of subsidised subscriptions.” He might be right. When a model is this capable, giving it away in a $20/month plan doesn’t make economic sense, especially when demand is “very high and unpredictable,” as Anthropic put it.

The window is small. If you want to see what the frontier actually feels like without per-token anxiety, the next thirteen days are it.

But the bigger story isn’t about pricing. It’s about what happens when a model this capable becomes the baseline. When “zero bugs from a single goal” stops being remarkable and starts being expected. When the question isn’t can it build? but did I describe what I actually want?

The companies that understand this shift will be the ones where humans spend their energy on clarity, direction, and taste — and let the model handle everything in between.

What I’m Doing With This

I’ll be running a set of spikes over the coming days, following Alex’s workflow. Advanced plan mode. Goal loops. Letting Claude ask the questions before I let it build.

The lesson I’m taking from today isn’t “AI is incredible now” — we’ve been saying some version of that every six months. The lesson is more precise, and it changes how I show up.

Be more planned and concrete upfront. Let AI do the job it’s now demonstrably capable of doing.

That means:

• Not jumping into /command with half an idea and iterating through twenty corrections
• Actually sitting with the problem long enough to articulate what success looks like
• Letting the AI ask clarifying questions — treating it like a collaborator who needs context, not a tool that needs instructions
• Trusting the output enough to verify at the end rather than micromanaging every step

The hard part isn’t technical anymore. It never really was. The hard part is clarity. The hard part is knowing what you want. The hard part is being willing to invest the thinking time upfront so the execution can be fast.

That’s the Growth Equation in a new light. The hard work upfront creates the freedom later. In a world where AI builds flawlessly, the “hard work upfront” is thinking clearly about what to build — and the freedom is watching it materialise while you focus on the next thing worth imagining.

So Here’s the Question

You’ve got thirteen days of free access to the most capable AI model ever made publicly available. It can build entire applications from a single well-described goal. It can modernise a 50-million-line codebase in a day. It can ask you the questions you didn’t know you needed to answer before it starts.

The bottleneck isn’t the model. The bottleneck is: do you know what you actually want?

Would you do the work upfront to describe it clearly enough that AI can handle the rest?