Field Report: Using Fable 5

It's still a tool, but it's an amazing tool

Midway through a 8-day sprint with Claude Fable 5, Anthropic’s newest model, I had to report for jury duty. In my county, that means sitting in a holding room, waiting to be called into a courtroom for voir dire. My number never came up. I sat there for two hours before being dismissed.

Instead of scrolling social media or reading the news, I spent those two hours coordinating a codebase reorganization from my phone, using Claude Code to direct Fable as it orchestrated the work. We’ve heard almost a year of hype about AI handling execution, about shipping features from coffee shops. This was different. An entire codebase reorganization is judgment-heavy, and I ran it from a jury holding room without supervising anything, because it wasn’t supervision. It was management.

That sounds like a small distinction and like overblown hype at the same time, depending on who’s reading it. In my experience, it was neither.

The experiment

One rule governed the sprint: Fable never writes final code. It plays architect and orchestrator, and the implementation goes to Opus and Sonnet acting as the engineering team. I play the principal. Set direction, make the calls only I can make, review the work.

And I did nearly all of it by voice. No prompts refined over ten drafts (I’ve written enough of those for a lifetime), just spoken instructions, dictated the way you’d brief a senior colleague in a hallway. Rambling and imprecise, full of the shorthand you use when you trust the listener to fill in gaps.

Voice input is a minefield for LLMs. They fail in a specific way. When we speak, tone of voice carries part of the message, and we count on the listener to receive it. When I first started using voice input with AI, I learned fast that I had to compensate with declarative sentences, a whole lot of them. That’s prompting 101, but it’s not human voice 101, and I had to teach myself to do it.

When I question assumptions out loud, I ramble and hedge, which is natural for me when I’m thinking something through verbally. With LLMs, I had to learn to announce it: this is me working it through, this is an unstructured brain dump, help me think. What I found was that Fable needs those announcements less. Prompting 101 is still prompting 101, but Fable infers intent from text alone far better than anything before it, and for voice input, that’s an enormous benefit.

The moment I knew

Early in the sprint, I dictated a memo with an offhand claim about how a transformer architecture had behaved in my past research. I said “majority,” as in: this pattern held in the majority of cases I’d seen. Experienced judgment, not a citation.

I know what most models do with a sentence like that, because I’ve lived it. They flag it as unfounded, hedge everything downstream of it, and you spend the next three turns defending your own experience to your own tool. The skepticism is healthy. The loop is exhausting.

Fable skipped the loop. It didn’t challenge the claim and it didn’t swallow it either. It wrote tests to check the claim empirically, delegated them to the junior models, reviewed the results, folded the verified finding into the plan, and documented the whole thing so I could audit the call later.

A junior challenges your judgment. A sycophant accepts it. A senior tests it. Resolving doubt with evidence instead of rhetoric is what you hire senior people for, and I watched a model do it without being asked.

It kept happening

A few days later, same pattern, different setting. I was doing exploratory analysis on output from a model I’d just trained, my first look at results from an unfamiliar system.

One return number came back around negative 400 percent. Anyone knows that’s an impossible result, but not Opus. Opus, running the same analysis, reported the number faithfully and moved on. When the data turned out to be riddled with missing values, same thing: 40 percent null, stated as a finding.

Fable’s reaction was closer to mine: that looks wrong, let me dig. It treated the impossible number as a symptom of a bug and went hunting for the bug. The nulls got the same treatment.

Here is where I argue against my own headline for a moment, because the nuance is real. Everything Fable did there is promptable with models like Opus. I could teach Opus to sanity-check outputs and treat anomalies as symptoms, and part of learning these tools is learning to teach them. But the teaching is the supervision overhead. With previous models, competence is something you install, correction by correction. With Fable, the reflex that impossible numbers mean something is broken comes standard. The whole difference lives in the defaults, and defaults determine whether you’re operating a tool or briefing a colleague.

What actually got built

Six days produced two substantial things.

The first was a migration I’d been dodging for months. My personal research platform, years of accumulated code and data, needed a ground-up reorganization. Projects like that never happen. The activation energy is enormous and the payoff is invisible until the very end.

I opened by asking Fable the question I’d put to any senior consultant, which is not how to do the migration but whether to do it at all. What’s the payoff, and what breaks if we skip it? The case it made was concrete. It compared the legacy dependencies against updated ones and worked out what the updates would buy in speed and security. For speed, it used my own throughput scale: this upgrade lets you run this many more analyses every week, across parameter sweeps and model runs. That speedup was pretty tremendous.

And then, there was the benefit I hadn’t fully articulated until we discussed it: the migration would make the codebase AI-native. Not so I’d stop writing code, but so coding agents could crawl it and work on it alongside me. The legacy codebase had no structure for that, for it was never planned with AI help in mind. I think that was the biggest benefit of all.

Then, Fable ran the project. It planned the migration in phases, dispatched implementation to teams of junior models (sometimes several working in parallel on separate parts of the codebase without stepping on each other), and validated everything against the old system. The data side was the easy part: about 6,000 files, already well structured, came over cleanly.

The code was where things got questionable. I had unorganized Jupyter notebooks from years of prototyping, and migrating those was rocky, because the original code was a mad scientist’s lab. How do you ask a robot to sift through a mad scientist’s lab? Fable did a surprisingly good job, but it took a couple of turns to decide what came over and where it went, and it hitched when it took on too much at once. I couldn’t just say migrate all ten of these notebooks; context got garbled. So I worked out memory stores better suited to Fable than to other models: restructuring each repo’s ARCHITECTURE.md, using pointers that Opus and Sonnet could read. Where something was ambiguous, Fable made a documented judgment call and flagged it for my review instead of stopping to ask.

The second build was a full strategy engagement. Over interactive sessions, Fable helped me define what to pursue over the next six to ten months and in what order. Then it did the thing that actually impressed me: it broke next steps into roughly ten work products and told me which ones deserved my live attention and which could be fired off and collected later.

Attention. It was helping me manage attention. That’s huge. Every opinion piece about dystopian modern technology ruining our brains focus on that: technology destroys our attention.

But here was something different. Fable was helping manage my scarcest resource, and managed correctly. The high-stakes design decisions got interactive sessions where I could push back in real time. The well-specified deliverables ran on their own. Juniors ask for direction on everything. Seniors tell you where your direction is needed.

The claim I disagree with

The consensus on the Claude subreddits, especially among people using Fable heavily, is that its edge over previous models only shows up on very complex technical work. My week says otherwise.

The clearest gap I saw was in ordinary conversation. Planning sessions, design discussions, sessions that never touched code. Forty turns into a session covering several research projects, Fable still had my constraints, my tooling, and my earlier decisions woven into its answers. Other models are good at this for a while, then the threads quietly drop and you’re re-explaining yourself to something that was nodding along an hour ago.

For me, this is the headline. The code orchestration is downstream of the thinking partnership, and a thinking partner who doesn’t lose the plot is worth more than a faster coder.

The honest caveats

It wasn’t flawless, and some of the flaws were mine to fix. Early on, Fable repeatedly misread how I actually work. Wrong assumptions about my workflow and tooling, and I burned turns correcting the same misunderstanding. The fix was embarrassingly managerial: I wrote it a short onboarding memo about my operating style, and the misfires stopped. Even excellent senior hires need onboarding. The difference is that juniors need onboarding plus ongoing supervision, and seniors need onboarding and then room.

The other thing that didn’t work: Fable would start doing things before I asked it to. Without a proper harness, it often went too far. Nothing disruptive ever came of it, just tokens spent before I could talk it through. One session I said: here’s the goal, but before we work on it I’d like to discuss some of the designs, and then we can implement. Fable read the handover documents and decided to implement some of the changes itself. It taught me to treat it as a very eager coding assistant.

Success also created its own management problem. I now hold validated plans and specifications representing threads implementation work. The architect outran the builders. Plans that pile up faster than execution capacity are a liability unless you triage them deliberately, but it’s a very, very good problem to have.

What this means

Every previous model asked me to be a supervisor, checking and directing everything. This one let me be a manager. If you’ve only ever handed these models tasks, try handing one a role instead.

We’ve had teams that never sleep for almost a year now. What’s new is that the management doesn’t sleep either: senior-level competence and judgment sitting next to the execution. The execution was already there. The judgment is starting to catch up.

Until next time, stay on the cutting edge, everyone.