A frontier model's judgment, packaged as a process any model can run.
Claude Fable 5 is remarkable, and it is also temporary: it launched with a note that it would eventually move behind higher subscription tiers. You can't own the model. You can own its process. Fable Mode is that process, extracted by Fable 5 from its own operating behavior while it was still the one doing the work, and written down as a Claude Code skill that elevates Opus, Sonnet, GPT, or any capable model.
Built by PixelCove, an agentic marketing agency.
Watch a frontier model work and the difference isn't just smarter answers. It scopes like a devil's advocate before it plans. It refuses to reason from memory about anything it could check. It attacks its own conclusions before adopting them. It never declares done on "seems to work." Cheaper models skip these steps, not because they can't do them, but because nobody makes them.
This skill makes them. Five gates, in order, where each must pass before the next opens:
- Scope before you work. Planning says "here are the steps." Scoping says "here is what could make those steps wrong." Testable success criterion, likely failure modes, named unknowns, and a check for a simpler path, all before the plan.
- Evidence before reasoning. Recognition from training is a hypothesis, not a fact. Files implied by a prompt may not exist. Recalled state is stale until re-verified. Every load-bearing claim traces to something read this session.
- Reason adversarially. Attack the candidate answer before adopting it, then hand it to a fresh-context reviewer that sees the artifact and its contract but never your reasoning (your reasoning biases it toward agreement). An adversarial review prompt is included in the skill.
- Verify before declaring done. Exercise the change end-to-end against the success criterion from Gate 1. A passing build is a precondition, not a verification. Weak signals (no errors, plausible output) mean the loop isn't finished.
- Calibrate and report. Effort scales to the task in both directions, more thinking is not monotonically better, delegation routes by role, and the final report leads with the outcome and attaches confidence: what was verified versus what was inferred.
The scoping gate is the one that changes the economics. When the thinking lives in the plan, cheap workers just execute and report, and the results match what far more expensive workers produce.
As a plugin (recommended):
/plugin marketplace add jongouveia/fable-mode
/plugin install fable-mode
Manual: copy skills/fable-mode/ into ~/.claude/skills/ (global) or
.claude/skills/ in a project.
Works anywhere skills work. The file is plain markdown, so Codex, Cursor, and open-source harnesses can load it as instructions too.
Invoke it explicitly when the problem in front of the model is hard, ambiguous, or high-stakes:
/fable-mode <the task>
Or let it trigger on its own description: it activates when the model doing the work is not frontier-tier and the task is non-trivial. If you run a budget setup (a cheaper default model with escalation reserved for hard gates), reference this skill from your routing rules so the downgrade keeps the discipline.
Trivial tasks skip the gates entirely. Running a five-gate process on a one-line edit is itself a calibration failure, and the skill says so.
It won't make a small model smart. It makes a capable model disciplined, which in practice closes a surprising amount of the gap: fewer confident wrong answers, fewer "done" declarations that weren't, fewer plans built on a file that never existed. The intelligence gap remains. The process gap doesn't have to.
The idea of extracting Fable's method into a portable skill comes from Nate Herk's article on keeping Fable 5's process after the model goes back behind subscriptions. This is an independent, free implementation: the gates here were extracted and expanded by Fable 5 itself, with inspiration credited where it's due.
MIT. See LICENSE.