You Have Until July 19th To Use Fable "For Free"

Read time: 12 minutes

Fable 5 is the most powerful model I’ve used. For website design, content work, security audits, prototyping, and most knowledge work, nothing else I’ve touched comes close.

By the end of this you’ll know what Fable actually is and how it stacks up against every other model, how to prompt it so you don’t waste it, how to run it for a fraction of the cost once it’s no longer free, and the five tasks I’d hand it today.

The “free” in the title has an asterisk on it. It means on your current subscription. You can run Fable 5 on the Claude plan you already pay for, up to about half your weekly limit, without spending a dollar more than you already do. The only pricey way to run it is through the API.

That subscription access is supposed to end July 19th. Hold that date loosely. This is the third deadline Anthropic has set for moving Fable behind the API. First it was July 7th, then July 12th, now July 19th. Every one has slipped, so nobody actually knows when it goes API-only.

Anthropic has also said that even after Fable moves behind the API, they plan to bring it back onto the subscription plans later on. And the prompting skills in this piece outlast any single model. If you’re reading this after the 19th, they’ll still help you get the most out of whatever frontier model lands on your plan next.

One real warning before you start: Fable burns through your usage limits fast. I’d run it on the Pro plan ($100 a month) at the floor, and I’m using it on Max ($200 a month). I hit 100% of my weekly limit with a minute left on the reset clock, then sat there refreshing the page so I could keep going. That was on Max.

I’ve never done that with an AI model before. Not once.

Anthropic shipped Fable 5 on July 1st, and I’ve been using it for hours at a stretch ever since. It’s a real step up from anything I’ve used, and different enough that the way you prompt it has to change.

I’m not the only one who noticed. Elon Musk has spent years taking shots at Anthropic. On July 9th he posted this:

When the person running a competing AI lab publicly hands you the lead, in front of 4.7 million people, it’s worth paying attention.

So the offer is simple: about a week of frontier-model access on the plan you already pay for. Starting with what it actually is.

1. What Fable actually is

Every Claude model before this one worked in short bursts. You’d ask for something, it would think for a bit, hand it back. Fable is built to sustain output over hours. Multi-day, goal-directed runs. It can hold a single task for up to 30 hours without you touching it.

That one change cascades into everything else. Because it can run long, it also:

• Gets it right the first time more often. Early testers reported single-pass builds of systems that used to take days of back-and-forth.
• Sees better. It reads dense screenshots, charts, and web apps far more accurately. If you feed it visual data, that jump is real.
• Reviews code and finds bugs at a noticeably higher rate than Opus 4.8, searching across a whole codebase and its history.
• Runs a team. It can dispatch and manage dozens of parallel subagents at once instead of doing everything itself.

The benchmarks aren’t subtle either:

Look at agentic coding. Fable hits 80.3% on SWE-Bench Pro. Opus 4.8 gets 69.2%. GPT 5.5 gets 58.6%. Gemini 3.1 Pro gets 54.2%. On Terminal-Bench it’s 88%. On the cybersecurity benchmark it nearly doubles the next model down. It’s ahead on almost every row.

But most people fall into the same trap. They get a stronger model and use it exactly like the last one. Paste in a vague request, get a mediocre answer, decide the hype was overblown. The capability jumped. Their prompting didn’t.

Where Fable pulls furthest ahead is long, ambiguous, high-stakes work: a full security audit, a prototype built end to end, a design overhaul across your whole site. But it’s also just better than what you’re used to on ordinary tasks. So the rest of this is about getting real output from it.

2. How to prompt it

The biggest shift is what a prompt is even for. Older models wanted every step spelled out. Fable wants a brief: the goal, the context, and room to figure out the rest.

Over-engineer the prompt and you cap it at your own thinking. Anthropic says it plainly in their official Fable 5 prompting guide: a short brevity instruction works as well as listing every rule you can think of. Say less, trust it more.

Five things carry most of the weight.

Match the effort level to the task. Fable’s effort setting trades speed and cost for intelligence. Reserve high and extra-high for complex builds: multi-step engineering, security audits, anything where the logic runs deep. For everything else you don’t need to crank it. On most non-engineering work, Fable at low or medium still outperforms Opus 4.8 and GPT 5.5 running on high or extra-high, and it’s faster. So the question is usually just which effort level to use, because even Fable’s floor clears their ceiling on most tasks.

Tell it why, not just what. Fable performs better when it understands the intent behind the ask, because context lets it connect your task to everything it already knows instead of guessing. The formula Anthropic recommends:

“I’m working on [the larger task] for [who it’s for]. They need [what the output enables]. With that in mind: [your request].”

Find your unknowns before you build. The quality of Fable’s work is bottlenecked by how well you’ve clarified what you actually want. Most bad outputs trace back to a decision you never made explicit. So before a big task, make it surface the gaps for you:

• Blind spot pass. “I’m adding a new auth provider but I know nothing about the auth modules here. Do a blind spot pass to find my unknown unknowns and help me prompt you better.”
• Interview me. “Interview me one question at a time about anything ambiguous. Prioritize questions where my answer would change the architecture.”
• Prototype first. “Before wiring anything up, make a single HTML file mocking the layout with fake data so I can react to it.”

Ten minutes of this upfront saves you hours of building the wrong thing.

Use one prompt structure for everything. Once you know what you want, Anthropic’s structure has four parts:

Context. The files, data, and the why. Request. What you want, in one clear sentence. Output format. Exactly how you want it delivered. Constraints. What it must not do or assume on its own.

Four lines is enough.

Set the checkpoints. Fable runs autonomously by design, so if you don’t tell it when to stop, it decides for you. For anything sensitive, add one line:

“Pause for me only when the work genuinely requires it: a destructive or irreversible action, a real scope change, or something only I can provide. Otherwise keep going and report back when done.”

Nail the why, keep it short, and let Fable handle the how.

The shortcut: let a cheaper model write the Fable prompt

You don’t have to write these by hand. Paste this into Opus or Sonnet along with your rough objective, and it hands you back a clean Fable prompt:

You are helping me write a prompt for Claude Fable 5, a very capable model that
works best when it understands the goal and is given room to figure out the how.

My objective: [describe what you want, messy is fine]

Do this:
1. Ask me up to 3 clarifying questions, but only about things that would change
   the shape of the result. Skip anything cosmetic.
2. Then write me a single Fable prompt with four parts:
   - Context: the larger task, who it's for, what the result enables, and the
     files or data to reference.
   - Request: what I want, in one clear sentence.
   - Output format: exactly how the result should be delivered.
   - Constraints: what Fable must not do or assume, and when to pause for me.
Keep it short. Don't over-specify the steps. Nail the why, leave the how to Fable.

Cheap model writes the brief, expensive model does the work. That’s the idea behind the next section.

3. Run Fable cheap: let it plan, let a smaller model execute

Once the free window closes and you’re paying API prices, one move matters more than the rest. You don’t need Fable running on every single turn. You need its judgment on the decisions that actually matter.

That’s Anthropic’s advisor strategy. A cheaper model drives the task end to end, handling all the tool calls and grunt work. When it hits a decision it can’t make well on its own, it escalates to the premium model for guidance. Anthropic built it with Opus as the advisor. You can put Fable in that seat:

Fable is the advisor. It plans, reviews the context, and sends advice. It never touches tools or writes the final output. Sonnet is the executor. It runs every turn, does the actual work, and only pings Fable when it’s stuck. You get Fable-level thinking on the hard calls while a cheap model handles the volume.

The numbers hold up. Anthropic found a Haiku executor with an Opus advisor doubled Haiku’s solo score on one benchmark while costing 85% less than running Sonnet alone. Same shape works with Fable up top: you’re paying premium rates only for the moments that need premium thinking.

So the rule of thumb once you’re on the API: Fable plans, Sonnet or Opus executes. Reserve the expensive model for the thinking.

4. Five things to run this week

These are the five I’ve been running. Every one is a long task worth handing to your most capable model, and they all follow the same shape: give it context, tell it to audit like a specialist on their first day, and tell it to report and stop rather than change anything. I packaged all five as copy-paste prompts in the Fable Prompt Pack (link at the bottom).

1. Audit your own AI setup. If you run Claude Code, point Fable at your config files, skills, hooks, and memory. Tell it to “audit it like a senior AI engineer taking over my setup on day one.” Mine came back as a priority-ranked report. One line stuck with me: 19,000 tokens burned before I type a single word, because my setup files had gotten so heavy. The constraint that keeps it safe: report and stop, don’t edit anything until I say go. (Credit to my co-founder Jimmy for that one.)

2. Audit your site’s design and SEO. I built prestonchin.co myself in Claude Code after leaving Kajabi. It looks fine. It’s not built for search, and the free resources sit in a pile with no order. So I had Fable screenshot every page, then hand back a redesign plan ranked by impact, covering SEO, information architecture, and design-system health. Anything structural stays a recommendation until I approve it.

3. Attack your own product. This is what we run on Melda, our tool that turns any video into short-form scripts. The wording is the whole game: “Audit this codebase from first principles for reliability and security, then attack it. Don’t pattern-match to a generic checklist.” It spins up parallel agents playing a hostile user, a careless user, a performance test. Told to break in instead of tick boxes, it finds what a checklist never would.

4. Build a prototype in one pass. I built Melda OS with Fable. A content operating system with a Kanban pipeline, a connected database, a chat agent, scheduling, and performance insights. The move that made it work: I spent 20 minutes first on a cheaper model letting it interview me to get the plan on paper. Then I handed Fable the plan and asked for the smallest version that actually works, end to end, with real design decisions. It wasn’t finished, but it was a real starting point instead of a blank page, and I’d never pulled that out of one prompt before.

5. Get an honest business read. I run a few things solo, so I asked Fable to audit my business like a sharp operator who just joined and to rank everything by leverage. It named my strengths. It also told me to kill a product I’d launched months earlier. The constraint matters here too: don’t flatter me, don’t hedge, don’t fabricate numbers, mark the unknowns as unknowns. I don’t take it as gospel. As a gut check on decisions I’d been avoiding, it’s sharp.

5. When the window closes: make Opus think like Fable

After July 19th, Fable gets expensive. The advisor pattern above is one answer. There’s a second one too. You can’t hand a smaller model Fable’s raw intelligence, but you can hand it Fable’s discipline: how it scopes a problem, gathers evidence, attacks its own answer, verifies, and reports.

I turned that discipline into a skill I run on Opus and Sonnet. Paste this at the top of any session and the output gets noticeably more Fable-like on planning, debugging, and review:

Run hard tasks through five gates, in order. A gate has to pass before the next opens.

1. SCOPE. Before touching anything, write what "done" looks like in one or two
   sentences: what exists at the end, what must be true of it, and how you'll check.
   Name the one to three unknowns that would change everything if you got them wrong.
   Ask me a question only if the answer changes what you'd build.

2. EVIDENCE. Never design from memory of what a file or dataset "probably" contains.
   Open it. Test the biggest unknown with the cheapest probe first. Get one thing all
   the way through the pipeline before scaling to everything.

3. ATTACK. Before committing to an answer, switch sides and try to break it: what
   input or edge case makes this wrong? Actually test that case. If it survives,
   commit. Two failed attempts at the same fix means the diagnosis is wrong. Stop
   patching and test the assumption underneath both attempts.

4. VERIFY. "It ran" is not verification. Check at the layer of the claim: if the
   claim is "the output is correct," look at the output. Use evidence you didn't
   generate. Check the first, last, and weirdest case, not just the middle. Treat a
   too-clean result as suspect until you can explain why it's real.

5. REPORT. Lead with the answer. Separate what you verified from what you assumed,
   out loud. Cite specifics: files, lines, the command you ran, the number you saw.
   Flag real risks once, concretely. Never call something done unless you watched
   the check pass.

Always on: turn "recently / latest / tomorrow" into exact dates and versions.
Surface a constraint or trade-off before it bites. Sort actions by reversibility:
reversible and in scope, just do it; irreversible or outward-facing, stop and confirm.

It won’t match Fable at full strength. But it closes a real chunk of the gap, and it costs you nothing. The full version, plus the five prompts above, is in the Fable Prompt Pack below.

---

Fable runs on your existing plan until July 19th. If you run one thing this week, make it the biggest task you’ve been putting off. Give it context, tell it why it matters, and let it work.

Preston

---

Free resources

• The Fable Prompt Pack. All five prompts above, ready to paste, plus the full one-paste “fable mode” skill for any Anthropic model. prestonchin.co/resources/fable-prompt-pack
• Newsletter Prompt Playbook. The AI prompts and workflow I use to write these issues faster. prestonchin.co/resources/newsletter-playbook