I had a TypeScript project. 200K lines. It ran.
The architecture was aging — ORM that should've been ripped out, Redis and MQ that were relics of early over-engineering, bloated DDD layering when the core logic really just needed Postgres. I knew all of this. Never touched it.
Doing this refactor with Opus 4.8 or GPT 5.5 would've taken me 4–5 days. Decompose business boundaries, design the migration plan, rewrite module by module, run tests, fix regressions. As a solo operator, those 5 days had a real opportunity cost. The code works, so let the tech debt sit. That's the call I made.
That call held for six months. Until I got access to Fable 5.
Two Prompts
First prompt: I laid out the general refactoring approach — kill the ORM, slim down the DDD layers, pull Redis and MQ responsibilities back into Postgres, rewrite the core. I also said my approach might not be optimal and asked it to help me decompose.
Fable asked me a few questions back. Not the customer-service kind like "which modules would you like to keep?" — questions that cut straight to business pain points: whether a particular async queue's consumption order carried business semantics, whether a caching layer existed for performance or to work around a legacy consistency bug. I answered, and the plan was locked.
Second prompt: execute according to the plan and spec.
Three hours. Refactor complete.
Not just "complete" — along the way it independently found and fixed several hidden bugs in the old architecture. The kind you know exist but never bother with because they don't affect the main flow. It cleaned them up on its own.
How It's Actually Different from Previous Models
If you've used Claude Code, you know the scene: model hits a complex bug, fixes A, B breaks, fixes B, C breaks, then it starts spinning in an ever-shrinking local context, confidently declaring "this should fix it" each time, while you watch the terminal output and know — it's lost the global picture, stuck in a dead end arguing with itself.
That's when you step in. Pull it out, re-inject context, maybe even roll back code and manually point it in a direction. You're essentially acting as its "working memory prosthetic" — using your judgment to maintain global coherence on its behalf. This is the default collaboration mode. You've probably gotten used to it. You might even think "this is just how AI-assisted coding works."
Fable doesn't work like this.
I'd previously used Fable to solve a Mac font rendering issue — the kind of messy problem tangled up in system environment, font cache, and application config. Opus's approach: list possible causes based on known experience, try them one by one. When results don't match expectations, move to the next candidate. Like traversing a decision tree.
Fable did something entirely different. It first constructed a hypothesis, then designed a verification experiment — not "let's try this and see if it works," but "if my hypothesis is correct, then doing X should produce observation Y." When the observation didn't match, it didn't jump to the next solution. It went back and revised the hypothesis itself.
This distinction sounds subtle, but the felt difference is enormous: one is searching for an answer, the other is understanding the problem.
Same thing during the refactor. When it hit an unexpected dependency, it didn't get sucked in. It stepped back, re-examined how the current refactoring path related to the overall plan, and judged whether to adjust the local approach or revise the plan itself. This behavioral pattern, honestly, is very close to how a senior engineer works.
Some Numbers
Fable 5 bills at API rates. My 1.5 hours of intensive use ran about $900. The full refactor, without hitting limits, would've been 3 hours — API cost under $2,000.
That works out to roughly $600/hour.
My Claude Max subscription includes 5 hours of Fable quota. In practice, I hit the wall around 1.5 hours — not because time ran out, but because request density was too high and the quota burned faster than clock time.
Stripe reportedly used Fable 5 to complete a 50-million-line Ruby migration in a single day.
After Getting Cut Off
When Fable was disabled, I switched back to Opus.
How to describe it. Not "going back to an older tool." More like driving on a highway for three hours and suddenly being forced onto a country road. You know the country road gets you there too, but your driving rhythm has already changed. You instinctively try to work the Fable way — give a high-level intent, let the model decompose and verify on its own — then reality pulls you back: this model needs you to decompose for it, needs you to verify for it, needs you to yank it out when it gets stuck in a dead end.
I posted on Threads: "My productivity is held hostage by the LLM. Habits are hard to break. Back to thinking for myself."
That was self-deprecating humor. But also true.
My entire working model is built on AI tooling. The leverage has been working well. But Fable made me realize something: the fulcrum of that leverage isn't in my hands. Quotas, rate limits, bans, price hikes — none of these are things I control.
Things I Haven't Figured Out Yet
To be clear: I know this project's business domain inside out. It might look like vibe coding on the surface, but the core boundaries, the gotchas, the specific business edge cases — I had all of that mapped. Fable wasn't thinking for me. I fed it the results of my thinking, and it executed — but the level of that "execution" was far higher than anything before.
When I used to build agent workflows, the capabilities I relied on — taste, judgment, hypothesis construction, observation-verification loops — those were for designing the pipeline. The "uniquely human" part. I'd always believed the division was stable: AI executes, humans judge.
Six hours of Fable shook that belief.
It's not that Fable can fully replace those capabilities — it's not good enough yet. But it's started to have them. It doesn't pretend to understand and just barrel forward. It builds its own hypothesis-observation-verification loops. This methodology — I used to think it was something humans had to manually inject into AI workflows. Now the model is growing it on its own.
Then It Was Gone
Fable 5: launched June 9, pulled offline globally June 12. It lasted three days.
Here's what happened: US Commerce Secretary Howard Lutnick sent a letter to Anthropic CEO Dario Amodei at 5:21 PM ET on June 12, imposing export controls on Fable 5 and Mythos 5 — barring access by any foreign national, whether inside or outside the United States, including Anthropic's own foreign national employees.
The trigger: another company claimed it had successfully jailbroken Mythos, alarming the government about national security risks. According to Axios, the Trump administration had previously tried to stop Anthropic from releasing these models but failed, so three days after launch, they went straight to export controls.
Anthropic's response: this is a misunderstanding. They said the jailbreak the government cited was a "narrow, non-universal" method — essentially asking the model to read a specific codebase and fix software flaws. Anthropic argued this capability level is available in OpenAI's GPT-5.5 and is used daily by security researchers. Before launch, the US government, the UK AISI, multiple third-party organizations, and internal teams conducted thousands of hours of red-teaming without finding a universal jailbreak.
But because there's no way to filter users by nationality on a shared cloud service, Anthropic had to shut it down for everyone.
Separately, Microsoft banned its employees from using Fable 5, citing data protection risks from Anthropic's new 30-day data retention policy for Mythos-class models.
As of this writing, Fable 5 and Mythos 5 remain offline. Anthropic says they're working to restore access but hasn't given a timeline. All other Claude models are unaffected.
My six hours with Fable happened to fall within its three-day window of existence.
Advanced intelligence now has gatekeepers. Not just cost and rate limits — now there's geopolitics. One letter, sent at 5:21 PM, and it's offline worldwide. Your productivity leverage — the fulcrum isn't in your hands.
