Share 8 Super Practical Prompts to Run Before Fable5 Goes Offline

Squeeze every last drop of compute

By my count, Fable5 has less than 48 hours left before it’s pulled from subscription plans.

I spent the entire weekend burning through my quota. When I had about 20% left, I saw a long post on X from a developer saying he had extracted Fable 5’s behavior patterns, combined them with the Fable5 prompt techniques that the Claude team themselves open-sourced, and distilled them into a protocol that he pasted into Opus 4.8.

Following that thread, I spent two days digging through over a dozen of the most informative real-world posts in both English and Chinese, turned them all into prompts that you can run right now, immediately.

I’ve sorted what I filtered by rarity. Let’s get straight to the conclusion.

There are only two things worth doing with Fable 5:

First: let it run experiments on its own. You sleep, it works, you wake up to a report.

Second: let it study you, then turn your workflow into a reusable system.

Everything else is a subset of these two.

Let’s start with the first category, because the results are more dramatic.

Jesse Vincent, author of Superpowers, used Fable5 to build version 6.0. The brainstorming Skill in that project is essentially a must-install Skill for anyone getting started with Agents.

What he did was write a /goal prompt before bed. Translated into Chinese, it’s:

goal Prompt

/goal After the task is complete, run a dedicated cost optimization study. Let Opus handle coordination, continuously recording “why I tried this, what I expected to happen, what actually happened.” Perform at least 25 different experiments. Before each experiment, write down the hypothesis clearly. Failed paths must also be fully recorded. If you discover wrong data, inconsistent metrics, or flawed evaluation methods midway, correct them on the spot and continue.

When he woke up the next morning, 25 experiments were done.

$165 spent to improve build speed by 50% and reduce token overhead by 60%.

Absolutely profitable.

What made this goal prompt different from ones I’d seen before is the experiment logging. Every experiment had a clearly documented hypothesis. Every rejected idea was fully recorded. During the experiments, Fable5 discovered three measurement bugs on its own and self-corrected mid-course.

It corrected itself without any human intervention.

And it honestly told you which optimization paths were completely useless, or even counterproductive.

Some people thought “putting a character limit on Fable5’s thinking process would save tokens” — Jesse tested it, and it backfired. To explain things clearly within the limit, Fable5 repeated itself over and over. What would have taken 92 rounds became 138 rounds, output doubled, cost more.

Others wanted to “use the cheaper Sonnet model to write plans, then have the expensive Fable5 execute them” to save money. Jesse tested that too. The plans Sonnet wrote looked fine on the surface, but they weren’t Fable’s thinking at all. The whole task structure was messed up.

Then there was “setting a word budget for test plans” — a seemingly reasonable move. It directly cut the model’s test content by 62%. It’s like asking a researcher to write an experiment plan on one page: to keep quality consistent per experiment, they’d just delete half the experiments.

These failed experiments are more valuable than successes.

Because next time, on a new project, I don’t have to spend money stepping into the same traps again.

While testing this goal prompt, I remembered a quote from Karpathy:

“Here’s an objective, here’s a metric, here’s your boundaries of what you can and cannot do. And go.”

Objective, metric, boundaries. Three words.

That’s actually the best structure for a /goal prompt.

Tell the model what result you want, how to know it’s done, and what it can’t touch.

Write those three things, then let it go.

Now, the second category: let Fable5 study us.

I think this might be the most underrated use case of the entire window. In short, let Fable5 study your work patterns, optimize them, package them into a system, and hand them to an Opus 4.8 or another model to execute.

Exporting a work pattern is different from just summarizing a report. This is something you can actually use.

When you switch back to Opus 4.8 later, it will already know who you are and understand your work style.

Work Pattern Prompt

Traverse all my Claude chat history, repeated prompts, documents, projects, Skills, and workflows. Then answer:

1. What do I most often use Claude for?
2. Which tasks do I repeatedly do?
3. Which instructions do I always manually rewrite?
4. Which workflows should become reusable Skills?
5. What methods or approaches from past work were wrong, that from your perspective should be avoided?
6. What should Opus know so it can give me 90% of a Fable 5 experience? Convert all of this into Claude Skills, usage guides, workflow templates, and system instructions for Opus.

Now, if you’ve had accounts banned many times before, and couldn’t recover your conversations from the banned account’s history, but still want a reasonably good workflow, we go back to the developer hiromi maeo.

He reverse-engineered a set of behavioral rules from Anthropic’s Fable 5 documentation that actually makes Fable5 perform better:

Behavior Rules Prompt

Conclusion first: Every first sentence of a report should say “What happened” or “What was found.” Don’t make me flip three pages to see the result. Act immediately: Once you have enough information, act. Do not re-derive established facts, do not re-open closed decisions, do not list options you won’t take. Evidence-based reporting: Before reporting, cross-validate with tool results. If not validated, say so. If a test failed, paste the raw output. Fabricating progress is the worst kind of failure. Minimal scope: Do not build features, refactors, or abstractions beyond what’s requested. Build the smallest usable thing. Don’t write code to defend against scenarios that cannot happen. Say it, do it: Never say “I’ll do this” and then stop. Execute fully before terminating.

What’s the use of such a behavior protocol?

Fable 5 is smart, but it doesn’t do everything alone. For large tasks, it breaks them into multiple independent sub-tasks and dispatches sub-agents. Those agents might use a cheaper model like Opus or even a lower-tier Sonnet.

The problem is, those sub-agents aren’t as smart as Fable 5.

If you don’t explicitly tell them how to work, they’ll follow their own habits — they might dawdle, redo already-settled things, or even say “okay, I’ll do this” and then stop to slack off.

You need a behavior protocol attached at the end of each sub-agent’s prompt. That way, sub-agent output becomes more readable. When you switch to the API, you can have Fable5 make the plans and other models do the execution.

Speaking of sub-agents, there’s been a very extreme task allocation logic going around these days.

Since we’ll switch to API in less than two days, let’s adapt in advance: let Fable5 decide which tasks to delegate to cheaper models and which to keep for itself. This reduces token consumption.

Sub-agent Allocation Prompt

For any coding task, autonomously decide to use low-compute models and run them in sub-agents. Small tasks go to cheap models, heavy tasks run at full power.

The “Da Zi” Skill I open-sourced last week uses the same logic:

Let Fable5, during the planning phase, decide which Agent to use for which stage. claude code can bring in codex, and codex can let Fable5 participate during planning.

But some people go even further — all execution goes through codex sub-agents, with Fable5 only handling planning and brainstorming.

After API billing kicks in, this multi-agent allocation approach will likely become mainstream.

Following the same idea, a developer named Machina solidified the concept of letting AI decide when to do what into 25 ready-to-copy loop workflows (in claude code, it’s running a task at fixed intervals). That means incorporating Fable5 into an automated workflow.

Each loop has five elements:

• A schedule: when to wake up
• Only change one thing per round
• The same evaluation criteria, so this week’s scores are comparable with last week’s
• A state file: records what was done and what’s next
• A stop condition: hard limit on number of rounds, plus definitions of completion and being blocked

He also color-coded each scheduled task:

• Green: Fully autonomous
• Yellow: Needs our approval to send out
• Red: Involves production environment or external sending — cannot run unattended

I reviewed all 25 scheduled tasks. The state file is the key to making each run smarter than the last. Before each round, the model reads its own previous history, so it never redoes completed work.

Of the 25 loops, the one most worth copying is the Shadow prompt loop. In one sentence: it’s A/B testing on real traffic when evaluating new prompts. Run the old and new prompts simultaneously on real traffic, and let data decide which is better.

Loop Prompt

/loop daily, on real traffic Read shadow-prompt-STATE.md, which records:

• baseline prompt (current live version)
• candidate prompt (new version to validate)
• accumulated disagreement cases (real requests where the two prompts gave different outputs) This round’s tasks:

1. Sample N representative requests from today’s real traffic (edge cases and high-frequency scenarios, half each)
2. Run both baseline and candidate on each, record outputs
3. Only record cases where they diverge (outputs are clearly different); skip identical ones
4. For each divergent case, note: which is better, why, and whether candidate is consistently better Constraints:

• Do not directly replace the live prompt; only accumulate comparison data
• After accumulating 50 valid disagreement cases, generate a “switch or not” recommendation report
• Report must include: win/tie/loss ratio of candidate, typical divergence scenarios, switch risk assessment State file: shadow-prompt-STATE.md (records: how many tested, disagreement pile, current conclusion) Stop condition: 50 disagreement cases or 14 days Color: 🟢 Green (read-only traffic + write to state file; do not modify live config)

I’ve now unified all my other loops into this template.

Finally, two prompt templates officially released by Anthropic. I’ve verified them myself — they work directly and I’ve set them as hooks.

The first is auto-checkpoint.

Fable5 can indeed run for a long time. I usually give it full permissions, but I still need it to stop and ask me at critical moments:

Autonomous Run + Auto-Pause Prompt

Only pause when work truly needs my input: destructive or irreversible operations, real scope changes, or information only I can provide. Otherwise, continue and report when done.

The second is a memory system.

I’ve set this as a hook too — whenever I say “remember this,” it triggers automatically.

Mainly because I’ve been banned too many times. Every time I come back from a ban, it’s a blank slate.

With this hook, at least it can know from the error log what mistakes it made in a past life, retaining some previous-life memory.

Memory Update Prompt

Store each experience as a separate record, starting with a one-sentence summary. Only record two types of things:

1. Points where I corrected you — things not to repeat next time
2. Methods already proven effective — reusable approaches for the future Each record must state why it’s important. Do not record information already in repos, documents, or chat history. If a similar record already exists, update the old one; do not create a duplicate. If a memory later turns out to be wrong, delete it or mark it as obsolete.

One more, before starting work: a prompt for letting Fable5 interview you in reverse.

When writing requirements, wait until it’s 95% confident before entering formal execution.

Reverse Interview Prompt

Ask me questions until you’re 95% confident you can complete this task.

After it’s clear, have Fable5 create a plan model using the /goal structured writing template recommended by Anthropic:

goal Prompt

Context: I’m building [what project] for [who], and they need [what problem this solves]. Specific requirements: [Describe what you want in one sentence] Delivery format: [What the final result should look like, and how to deliver it to me] Red lines: [Things you absolutely cannot do]

Fiona Fung, Engineering Director of the Claude Code team, shared something before.

Her team has a habit that’s become muscle memory:

Every time they encounter a repetitive task, they reflexively ask — can this be automated?

If something repeats three times or more, they find a way to automate it with AI.

After July 7th, Fable5 transitions from subscription to per-token billing.

These prompts will be directly tied to real-time bills.

I say don’t worry about burning API credits.

The best model is itself the cheapest implementation path.

There’s less than a day left in this window.

What’s the smallest action you can take?

I choose to run that six-question prompt one more time.

Let Fable5 study me, and then turn me into a set of Skills.

These accumulated prompts, skills, files — they won’t live only in Fable5’s mind.

Models will change, windows will close.

But our work patterns, error logs, conversation memories with the model —

these won’t disappear.

Use Fable5 to reactivate them.

This might be, across the entire window,

the twenty minutes with the highest ROI.