The most expensive prompt I sent during Fable 5's first week back was 41 words long, and only the first nine did any work. I was wiring a new capture flow into my Obsidian-plus-Claude-Code setup and fired off one of those belt-and-suspenders instructions the Opus 4.7 era trained into me — do this, but not that, and explain your reasoning at each step, and be thorough. On older models that prompt was merely inefficient. On Claude Fable 5, which bills $10 per million input tokens and $50 per million output, it was a small fire — and the "explain your reasoning" line risked something worse than cost, which I will get to in Habit 5. On this model, prompting stopped being a style preference and became a cost control.
Six habits rebuilt how I talk to it. Each one makes the output better and the bill smaller at the same time, which is rarer than it sounds.
Why Fable 5 Punishes Sloppy Prompts Harder Than Any Model Before It
Two cost mechanics, and then the habits make themselves obvious.
First, Fable 5's internal reasoning — the thinking it does before answering — bills as output tokens at that $50-per-million rate, and you never see most of it. A reply that reads as 300 words can have burned ten times that in reasoning. Second, effort levels (low, medium, high by default, then the top tiers) do not change the per-token rate; they change how many of those expensive thinking tokens the model buys. Crank effort and you have not made tokens pricier — you have ordered more of the priciest ones on the menu.
Put together: the cost of a Fable 5 task is set less by what you ask than by how you ask. A vague prompt makes the model reason in circles at $50 a million to reconstruct what you meant. The habits below all attack that one waste from different angles. (For which tasks deserve this model at all, my free-window workflow map is the companion piece — that post is the to-do list, this one is the how-to-say-it.)
Habit 1: Give It the Why, Not Just the What
The highest-return change was the least intuitive: write more context to spend fewer tokens. A bare imperative — "write an email about the delay" — forces the model to reconstruct your intent, and reconstruction is exactly the open-ended reasoning that runs the meter. Compare:
Weak: "Write an email to the client about the timeline slipping."
Strong: "Write an email to a client who's the anchor customer for a bigger rollout next quarter — the relationship matters more than this deadline. Timeline slips two weeks. They should feel informed and in control, not managed. Short, specific about new dates."
Every clause in the second version removes a branch the model would otherwise explore on its own dime: tone, stakes, length, goal. You pay a handful of input tokens at $10 a million to avoid a pile of reasoning tokens at $50. In my second brain the "why" is often just a pointer — "this is for the Q3 partner review; draft against what we agreed in the last sync" — which tells the model which context files matter and what success looks like. Context beats configuration, on this model more than any before it.
My working rule: whenever I catch myself typing a bare imperative, I stop and add the clause that starts with "because." Nine times out of ten it is the most valuable sentence in the prompt.
Habit 2: Tell It What Not to Do
Context says where to go; fences say where the cliffs are. The failure mode fences prevent is unrequested initiative — you ask for a bug investigation and get three "helpfully" refactored files, which at these rates is a double tax: premium tokens for work you did not want, plus your time undoing it. The fences I keep on rotation:
- "Report findings only. Don't change files." — for any investigation or audit pass.
- "Don't add dependencies unless there's no reasonable alternative, and flag it first." — kills scope creep cold.
- "Touch only what I named. Don't rewrite sections that already work." — for edits, where every model over-reaches.
One nuance learned the hard way: negative prompting works with positive framing, not instead of it. "Don't break the tests" is weaker than "keep every existing test green, then add coverage for the new behavior." Target plus fence. The deeper version of this discipline is in my prompting rules that reduce guessing — invention is where both bugs and bills come from, so leave the model as little room to invent as possible.
Habit 3: Permission to Act, and Effort Matched to Stakes
Capable reasoning models over-prepare. Ask an open question and you get research, six weighed options, and a plan for the plan — expensive throat-clearing before an answer that was reachable three steps ago. So I say, in plain words:
"Gather what you actually need, then proceed. Once you have enough to act sensibly, act. If you hit a fork you can't resolve, ask me one sharp question instead of guessing."
Fable 5 follows that instruction well; its reasoning is good enough to know when it has enough, if you give it permission to stop.
The other half is the effort dial, where most of the money hides. Low or medium for lookups, renames, boilerplate. Default high for real feature work. The top tiers only deliberately, for the genuinely gnarly — the same discipline I mapped in my Opus 4.8 effort-levels review, which transferred to Fable 5 wholesale. Pick the lowest effort that will actually do the job, not the highest you can afford.
And the biggest lever is not a prompting habit at all: most of your work should not run on Fable 5. In my routing it carries maybe 5-15 percent — the deep passes where its ceiling genuinely changes the outcome — while Opus 4.8 and cheaper models carry the routine load. The general math is in my AI agent cost optimization guide, and it applies double at these rates. The best Fable 5 habit is knowing when not to prompt Fable 5.
Habit 4: Make It Prove "Done"
Every model occasionally declares victory it has not earned — tests "passing" that never ran, a fix "applied" to a misread file. On a premium model the false-done is doubly expensive because you trusted it more. So the contract goes in the prompt: "Before you call this done, run the tests and show me the output. If you can't verify something, say so explicitly instead of asserting it." Evidence, not confidence. This habit costs a few output tokens and has caught more silent failures in my pipeline than any other line I write.
Habit 5: Strip Reasoning-Exposure Language — the Fable-Specific One
This is the habit that did not exist before this model. Fable 5 came back on July 1, 2026 with an upgraded safety classifier running alongside it, and that classifier reroutes flagged requests to Opus 4.8 — with a notification, but one that is easy to miss mid-session. The flagged categories include certain security and biology agent loops, and, relevant to everyone: prompts asking the model to echo or explain its internal reasoning can trip the reasoning-extraction category.
Which means the beloved "explain your reasoning at each step" boilerplate — harmless habit on every previous model — can now quietly get your request answered by a different, cheaper, weaker model than the one you are paying for. You save money on the downgrade and lose the entire point of choosing Fable 5 for the task.
The fix is free: scrub reasoning-exposure language from your Fable 5 system prompts and skills, and get your accountability from Habit 4 instead — ask for evidence and results, not an exposed thought process. I keep two versions of my system prompt now: a Fable-safe one with all "show your thinking" language removed, and a normal one for other models. And for high-stakes Fable 5 work, actually check which model responded; if your tooling does not surface that, run the task somewhere that does. Independent testing after the relaunch found agentic coding loops getting rerouted at surprising rates, especially anything security-adjacent — legitimate defensive work included. Assume the classifier is tuned tight and verify the responder.
Habit 6: Say Less
The Opus 4.7 era trained us to stack rules — fourteen-line system prompts fencing every edge case. Fable 5 inverts the economics: it is intelligent enough that a tight, well-aimed prompt outperforms a rulebook, and the rulebook costs input tokens on every call while inviting reasoning across all that ceremony at output rates. My content pipeline's fourteen-line rule list became three sentences — "Lead with the outcome. Keep it simple and specific. Only pause to ask when the work genuinely needs a decision I haven't made" — and the drafts got cleaner, because the model was never struggling to obey the rules; it was being distracted by them.
The catch, so Habits 1 and 6 do not collide: less is not vague. The why, the goal, and the fences stay; the defensive over-specification goes. Trimming ballast is also what lets the architecture around the prompt do its job — skills, context files, system prompts — which is the shift I traced in loop engineering vs prompt engineering. Say less in the prompt so the system can say more.
Push the Habits Below the Prompt
Habits you must remember are habits you will skip at 11 PM on a deadline, so mine live in the layer beneath: the invariants (proceed-when-ready, verify-before-done, no reasoning-exposure language) baked into the system prompt; the fences and verification loops encoded inside skill definitions so invoking the skill invokes the contract; and effort defaults mapped per task type once, instead of chosen by feel per prompt. The destination of all six habits is not a more disciplined human typing better sentences — it is a setup where the discipline is structural and the expensive mistakes get caught by design.
That 41-word prompt from the top leaked four ways at once: runaway reasoning, a reroute risk, unfenced initiative, rules stacked where context belonged. The same instruction worded two ways can differ by an order of magnitude in what it burns and whether it even runs on the model you meant. Take the prompt you send Fable 5 most often and run it through the six — add the why, set the fences, demand verification, strip the reasoning-exposure line, then cut it in half — and watch the token counter tell you what your old habits were costing.
The system-prompt templates and verify-loop patterns I use for exactly this are in my prompt library, organized by task and free to adapt — including the Fable-safe variants with the reroute triggers already scrubbed.
