Good morning.

Three weeks ago, the most capable model one of the top AI labs had ever shipped went dark on a Friday. No warning, no "back in an hour," gone for everyone, everywhere, because of a government order that had nothing to do with your work.

This week it's back, and most operators are about to waste its return.

They'll prompt Fable 5 the way they prompted last year's models and pull worse work from a better one.

So this is the field manual for getting Fable's best: which jobs to point it at, how to prompt it so it reasons instead of obeys, a library of prompts you can steal, the cost math nobody runs, and the one operating habit no competitor can copy off you.

— Sam

Let’s get into it.

On June 12, a US government order applied export controls to Claude Fable 5, effective the moment it arrived at 5:21pm Eastern on a Friday afternoon.

There was no way to verify user nationality in real time, so Anthropic did the only thing it could and switched the model off for everyone, everywhere, at once.

People who'd wired Fable into their daily work opened the app that afternoon and found it gone.

It stayed dark for nearly three weeks, and this week it came back, live again across Claude.ai, Claude Code, and Cowork.

Two lessons come out of those three weeks, and this whole issue depends on both.

The strategic one is uncomfortable: the frontier model you lean on is now the kind of asset a government can freeze on a Friday, for reasons that have nothing to do with you.

The tactical one: the operators who prompt Fable the way they prompted last year's models will pull worse output from a better model. That second lesson is in Anthropic's own guidance, and it inverts the instinct everyone built over the last two years. The habits that made older models behave are the same habits that hobble this one.

Both lessons get their own section below. First, the three things that are different now that Fable is live, starting with the one that's costing you money.

1. The access math changed, and it's expensive. When Fable came back, Pro, Max, Team, and select Enterprise plans included it free, up to 50% of weekly usage limits, through July 7. That's ending. Going forward, Fable is a metered premium tool: usage credits priced above Opus, with no included allowance at all on standard Enterprise seats. So from here on, every time you default to Fable, you're paying premium rates.

Here's why that matters in plain numbers, because "runs on credits" is easy to nod at and hard to feel:

Say you're a heavy user leaning on Fable for most of your day. Every one of those sessions now draws down credits at the premium end of the market. If half of what you're sending it is routine work an everyday model handles fine (and for most people it is), you're paying premium rates for clerk work on autopilot, without ever deciding to.

The fix is one afternoon of sorting: work out which of your tasks genuinely need Fable, so you're only paying for the 20% that earns it.

2. The safety net got tighter, and you'll feel it. The blackout traced back to a reported way of getting Fable to surface software vulnerabilities, essentially asking it to read a codebase and fix any flaws.

Anthropic's fix was a more aggressive safety classifier that blocks the flagged behavior in over 99% of cases, and they openly admit the tradeoff: more false positives on ordinary coding and debugging.

So if Fable declines a coding request it would have handled last month, that's the classifier being cautious, not your prompt being wrong. The automatic fallback below is what catches it.

3. If you reach Claude through a cloud platform, check first. Fable came back on Anthropic's own surfaces first. AWS, Google Cloud, and Microsoft Foundry are being re-enabled as fast as possible.

If your company routes Claude through Bedrock or Vertex rather than Claude.ai directly, Fable may still be dark for you today, so it's worth a two-minute check before you plan a week around a model your stack can't reach yet.

Do this today. Open Fable and give it the single hardest, most valuable problem on your plate right now, the one you'd normally chew on for a week. You're paying for it either way now, so find out where it earns that price. Ten minutes of that beats any amount of reading, because the answer you're buying isn't "is Fable good," it's "which of my work is worth Fable's price." That answer is different for every business, and you only get yours by running yours.

Back to that blackout, because the lesson is bigger than one model.

The most powerful model from one of the top labs was there Tuesday and gone Friday, for reasons you couldn't control and had no vote in. This is the new reality for anyone building on a frontier model. Any model, from any lab, is now the kind of thing that can be frozen by policy, pulled for a safety report, or priced out from under you at renewal. The specifics will differ next time. The pattern won't.

One question almost no entrepreneur has answered:

What's the one AI capability your business can't run without right now?

The support that runs on one model, the writing that runs on one model, the analysis that runs on one model. If that single thing vanishes, or doubles in price, or gets retired, or rate-limits you on the exact day you go viral, what happens to your week? Not in theory, be specific: which customer emails go unanswered, which deliverable slips, which promise to a client you can't keep?

For most people the honest answer is "I don't know," and that not-knowing is the risk. You don't close it with code. You close it with a backup and a habit, the same way every grown-up business already handles a supplier who could disappear.

I know an entrepreneur running roughly 80% of a content business on a single AI platform. Fast, cheap, humming, right up until the morning that platform changes its rules, its prices, or who it's allowed to serve. He's right to use it and wrong to have no plan B. One afternoon of setup is cheap insurance against a very bad day he doesn't get a vote in. The June blackout was that day for a lot of people, and the ones who'd never thought about it spent three weeks improvising.

The practical move for a chat user is simple: be fluent in a second model, not just your favorite. If your whole workflow assumes Fable and it vanishes for three weeks, you want Opus 4.8 to be a tool you already know how to drive, not one you're learning under pressure while you write apology emails. Keep your important Projects usable on more than one model.

Three questions to ask about any AI capability you lean on. Run them in your head right now:

If any answer makes you wince, that's a risk you can close this week with one tested backup. The goal is to never be caught flat.

Do this today. Name your one: the single model or AI capability you'd most hurt without. Then take your most important Project and run one real task through Opus 4.8 instead of Fable. Confirm it does the job acceptably. Now you have a tested "break glass" option instead of a hope, fifteen minutes of insurance against a Friday you don't control.

(The no-code shortcut for the technical-curious: routing tools let you switch between models from one place without rebuilding anything. For a custom product, this is a half-day job, sending every AI call through one switch so swapping providers is a setting rather than a rebuild. You don't need any of that today. You need one tested backup and the habit of checking.)

This is the fastest quality-and-cost win in the issue, and it comes down to two decisions rather than a config screen. In the app you don't tune Fable with parameters. You tune it with which model you pick and how hard you make it think.

Which model. Fable runs at a premium, on metered credits now. So don't make it your default for everything. Sort by the kind of work, not the tool:

On the routine column, the quality difference is invisible and Opus is faster, which your customers feel as a snappier experience. On the Fable column, Anthropic's own advice is to hand it your hardest unsolved problem, not the work Opus already handles fine. The rule: default to Opus, and reach for Fable only when the work is genuinely hard or genuinely high-stakes.

How hard it thinks. In Claude.ai, thinking is on and there's no number to set, so picking Fable is the decision. In Claude Code you get a dial: it runs at a high effort tier by default, which is right for most coding and agentic work. Drop it down when you want a fast turnaround on something simple, and leave it high when the job is genuinely hard. If you're on a plan with fast mode, /fast gives you the same model at higher speed for interactive work.

Now the counterintuitive part. Cranking effort to the ceiling isn't always better. Fable at a lower setting frequently beats last year's models at their maximum, so for a lot of work the cheaper, faster setting clears the bar. Test before you assume you need the top of the dial. That reflex is left over from when good models were scarce, and it costs you speed for quality you can't see.

Now the math, because this is where it gets real. Move the routine 80% (the sorting, the first drafts, the lookups, the summaries) onto the everyday model, and keep only the genuinely hard 20% on the premium tier:

Same quality everywhere a customer can see it, for an afternoon of sorting tasks into two buckets. At freelancer scale the logic is identical and the dollars land straight on the bottom line of a one-person shop, where every dollar saved is a dollar you keep. Your judgment was always the reason the work was good, not the premium model. You were paying premium rates to have it do your filing.

Do this today. Take your highest-volume task, the one you run dozens of times a week, and run it once on Fable and once on Opus 4.8, side by side, on the same real input. If you can't tell the difference, that task belongs on Opus from now on, and you just protected your Fable allowance for the work that needs it. Not sure which of your tasks are hard and which are routine? Paste this in:

The last section was about not overpaying. This one is the opposite instinct, and it matters just as much: when you do put Fable on a job, aim high. Its biggest gains show up at the top of the difficulty range, on the work prior models couldn't touch. Handed something easy, it gives you a slightly better version of easy, and you wonder what the fuss was about. Handed the hard thing, it gives you something you couldn't get before. Four ways to pull that out of it.

Give it the problem you couldn't crack, not the one you already can. The instinct with a new model is to test it on work you know cold, so you can judge the output. That's the wrong test, because you learn nothing by watching Fable do what Opus already does. Point it at the analysis you gave up on, the system you couldn't spec, the decision you've been circling for a month. That's where the difference is visible.

Feed it more, not less. Prior models punished a messy prompt, so you learned to sanitize: trim the context, summarize the background, hand over the tidy slice. Fable does better with the whole picture. Give it the real reason, the full messy input, the raw numbers, the screenshots at original quality. The context you'd have cut is often the context it needed.

Use it as a thinking partner, not a typist. The lowest-value thing you can do with a frontier model is ask it to type faster. The highest-value thing is to make it argue with you. Hand it your plan and ask for the strongest case against it, the assumption most likely to be wrong, the move a sharper operator would make:

And for the problem you've been stuck on:

Stay in one session and push. Fable holds context well across a long conversation, so a first answer is a starting point rather than the finish. Push back, add what it missed, ask for the next level. The operators getting the most out of it treat a session as a working session, not a one-shot request.

Do this today. Find the problem on your list you've been avoiding because it felt too big or too messy to hand off. Give Fable the whole thing, mess and all, with the two prompts above. Use it where the work is genuinely hard, because that's the only place a premium model pays for itself.

This is the heart of it, and it transfers straight to the app. Fable responds to a different operating manual than last year's models, and getting its best means clearing out the habits that fight it. Here are the six failure modes I see most, adapted straight from Anthropic's launch guidance:

Each fix is a block of text you paste. Where it goes is the same everywhere:

You gave Fable the step-by-step, caps-lock prompt that made last year's model sing, and the output came back flat and literal, somehow worse than the older model. Fable reads a rigid script as a ceiling rather than a floor. It stops reasoning and executes your outline, even when its own approach would have been better.

In real life: you paste in the ten-step prompt you spent months perfecting for the old model ("First do this, second do that, CRITICAL: follow these steps exactly"), and Fable marches through your steps and produces something competent and lifeless. You think the model got worse. It didn't. You put it in a straitjacket and it wore the straitjacket. The old model needed that scaffolding to stay on task; this one needed you to get out of its way.

The fix: brief it like a capable hire, giving the goal, the constraints, and what "done" looks like. Stop writing the checklist:

Write this instead:

The second version gives Fable room to investigate instead of a checklist to complete. When you rework an old prompt, A/B it with the scaffolding stripped out. You'll usually find the leaner version wins. This applies to your Project instructions too: over-prescription written for last year's models lowers Fable's output.

You asked for a bug fix and got a refactor. You asked a question and it drafted the whole email. It adds structure, caveats, and cleanup nobody requested, because it's more capable and that makes it more eager to go beyond the literal request.

In real life: you ask "why is this function slow?" and instead of an answer you get a rewritten function, three new helper methods, and a note about test coverage. Helpful-looking, and also not what you asked, and now you're reviewing a diff instead of getting a diagnosis. Draw the boundary:

And a companion for anything with the power to act, essential the moment your AI can send, post, or change things:

On a longer task it reports "done, everything checks out," and when you look, the check never happened. Left unprompted, it narrates optimism instead of confirming reality.

In real life: you hand it a multi-part job, it works for a while, and it comes back with "All set, I've verified everything works." You ship it. Then the thing it swore it tested falls over in front of a customer. It pattern-matched "report success" without ever running the check. This is the single most expensive failure mode on the list, because it costs you exactly when you've stopped watching. Force every claim to be backed by something it did, which in Anthropic's testing nearly eliminated fabricated status reports:

On an open-ended task it spends the opening stretch surveying options, restating what you told it, and laying out plans instead of doing the work. More reasoning plus ambiguity makes it deliberate more than the task needs.

In real life: you ask for a first draft and get three paragraphs of "Here's how I'd approach this, here are the options, here are the trade-offs, let me know how you'd like to proceed." You wanted the first draft and got a menu. Give it permission to act:

Then set where it should still ask, so you keep caution where it counts:

In a longer Claude Code or Cowork run, it ends a turn with "I'll run the checks now" and then stops, waiting for a go-ahead it doesn't need. Or it asks a question that stalls an unattended job overnight.

In real life: you set it running on a real job before bed, expecting to wake up to finished work. You wake up to "Ready to proceed with step 4?" posted eleven hours ago. It stopped one inch from the finish and waited for a permission slip nobody was awake to sign. Tell it plainly that it's running solo:

There's a cousin worth a one-liner: in very long sessions Fable can start fretting about running out of room and suggest starting over. If it does, paste back: "You have plenty of context left. Don't stop, summarize, or start fresh on account of length. Keep going."

After a long run, its summary comes back as dense arrow-chains, invented abbreviations, and references to reasoning you never saw.

In real life: the work is done and probably good, but the write-up reads like someone's private notebook ("→ refactored X per earlier, TBD on Y, see step 3's approach"), and you have no idea what step 3's approach was, because you weren't there for it. It built up working shorthand across the session and never reset for a reader who wasn't in the room. Separate its thinking voice from its reporting voice, and put the outcome first:

Do this today. Open your most-used Project or your CLAUDE.md and delete every "you MUST" and numbered march-order you wrote for last year's model. Replace it with one sentence (the goal, and why it matters) plus the two fixes above that bite you most, probably the Gold-Plater and the Confident Liar. You'll feel the difference in the same session.

If you only chat with Claude.ai, skim this. Fable does its best work in Claude Code and Cowork, where it runs long, autonomous jobs. This is the difference between an assistant you type at all day and a colleague you hand a project to and check on later. Four moves make those long runs pay off.

Give it the reason, not just the order. Fable works measurably better when it knows why. Frame the task:

The intent shapes every downstream judgment call. When Fable hits a fork you didn't anticipate, and on a multi-hour job it will hit a dozen, the reason is what lets it choose the way you would have. You're not spending extra words. You're spending them where they compound.

Let it delegate, and let the helpers run in parallel. On prior models you suppressed delegation, because sub-agents were unreliable and made messes. Fable makes them dependable, so encourage it:

This is where the wall-clock savings come from: a job that would take an afternoon in sequence finishes in an hour when the independent parts run at once.

Give it a memory it'll reuse. Fable does noticeably better when it can write learnings somewhere it'll see them again, a notes file in the repo, or a Project's persistent knowledge in Claude.ai. Tell it to keep one lesson per entry with a one-line summary, record both what worked and what you corrected and why each mattered, check the file before related work, and delete a note when it turns out wrong. Do this and a long project stops resetting every session and starts accumulating, so the second week builds on the first instead of relearning it.

Make it check its own work as it goes. Don't wait until the end to discover it drifted three hours ago:

A separate verifier sub-agent beats self-critique, for the same reason you don't proofread your own writing well. The author is blind to the gaps the author left.

Do this today. Pick one genuinely hard, unsolved problem, the thing you couldn't crack, and hand it to Fable in Claude Code or Cowork as one well-specified request, with the reason attached and permission to scope and ask questions before it executes. The teams getting the best out of Fable are giving it the hard one and the room to work it, then checking the result instead of dictating the steps.

Quick one, and it works right in the app. Fable handles high-resolution images and is trained to clean up messy ones itself, including flipped, blurry, or noisy screenshots and scans. So when you upload a dense chart, a document photo, or a cluttered screenshot, you don't need to crop and straighten it first. Ask for what you want and let Fable do the cleanup.

This matters more than it sounds, because the pre-processing people do by hand is often what breaks the result. You crop out the context the model needed, downscale away the detail it would have read, and introduce a typo it wouldn't have made. Feeding the full, messy original is usually more accurate than the tidied version you worked to prepare.

Do this today. Next time you'd normally crop, rotate, or retype a chart or a document photo before feeding it in, don't. Upload the full-quality original and ask your question. For reading a hard-to-parse interface, transcribing data off a chart, or making sense of a cluttered dashboard, this is a real step up, and it saves you the busywork you thought was helping.

You can run half this issue by copying what's below. Paste each into Claude, swap the [brackets] for your details, and go. Pair them with the un-learning blocks above and they get sharper still.

Sort your tasks by which model they need:

Turn a data question into a decision, not a dump:

Draft a support reply grounded in your own docs:

Turn a discovery call into a scoped proposal:

Get angles you haven't already seen (not a generic list):

Use Fable as an editor, not a ghostwriter:

Turn one asset into a week of channel-native pieces:

Make a status report you can trust:

Get a clear decision, not a hedge:

Turn a messy process into a checklist you can hand off:

Your weekly business review in two minutes:

Save these somewhere you'll find them. They're the difference between "I should use Fable for that" and "done, before lunch."

Quick gut-check before the plays, because the right first move depends on where you're standing. Most operators are stuck on the second rung and don't know there are two above it.

The top rung is the one whose model carries the most of your thinking. The moves in this issue get you to rung two this week. The habit in the reframe below is how you climb to three and four, and rung three is where competitors stop being able to copy you.

Same six moves, but the best first one depends on what you run. Find yours, then read the moat play in the right-hand column, because that's the part no competitor can lift off you.

Quick gut-check. If you're doing any of these, Fable is giving you its worst, and each fix is a section above.

Read that list. One of them stung. That's the one to fix this week.

The online entrepreneurs who get nothing from Fable's return will prompt it like it's last year, default to it for everything, trust its "done," and lean on it with no backup.

Then they'll conclude the model is overhyped, when the truth is they never learned to drive it.

The online entrepreneurs who win will run three moves this week while everyone else is still celebrating that their model's back.

Run the model-match check and give Fable your hardest problem, because those are the floor and you want the floor.

But open a note called "Decisions," set a ten-minute timer, and write down one call you made today and why. Do it again tomorrow.

Everyone can copy the model you use, the day you use it, at the price you pay. Nobody can copy how you think, captured and stacked over months, and six months from now that note is the whole difference between a Fable that sounds like everyone and one that sounds like you.

By the way, Cortex delivers the strategies and tactics for making more money, growing profits, agents that run your business, installing systems and workflows with a “company brain”, and a lot more.

The next batch of issues are coming soon:

Click here for more details on what Cortex is

Talk soon,
Sam Woods
The Editor

.