Repo of the day: the «Fable method», the discipline that keeps AI agents honest

🔍 What the «Fable method» is

fable-method is a distillation, curated by the community and not by Anthropic, of how Claude Fable 5 tended to work. The author wrote it during sessions with the model in its final days before deprecation: the model drafted the first version of its own method, three critic agents attacked it, and every surviving rule earned its place by fixing an observed failure. The result ships under the MIT license and is summed up in three words: think, act, prove.

The name «Fable method» grew from the bottom up, as many craft techniques do: in the weeks after Fable 5 shipped, people using it all day noticed it had a recognizable way of proceeding — it slowed down at the start to pin the goal, and refused to declare victory without checking. The point of fable-method isn't the model itself, which is no longer on subscription, but making that discipline portable: getting even smaller, older or cheaper models to follow it literally, when on their own they wouldn't.

repo       Sahir619/fable-method
what       Claude Fable 5's way of working, as reusable skills
essence    think (fable-method) · act (fable-loop) · prove (fable-judge)
extra      fable-domain: generates «adapters» for domains beyond code
how        Claude Code plugin, standalone skills, or AGENTS.md for any agent
license    MIT · a few weeks old, still few GitHub stars

🔁 The loop: think, act, prove

The core is a loop with seven steps and a shortcut. If the ask is trivial — one file, under ten lines, nothing to search — you do it, run the one obvious check, and answer in two sentences. Otherwise you enter the loop: classify the ask (a question? a task? does it need a plan first?), define what done means with a named verification, gather evidence in parallel from primary sources while stating your intent before touching anything, decide on a single recommendation, act with surgical edits, verify by observation, and finally report the outcome first, with honest caveats.

The part I appreciate most is that every arrow has hard bounds and escape hatches, not just good intentions. Three failed verify cycles and the agent stops and hands control back; two fruitless lookups and it stops searching; if it can't name a verification, it asks one pointed question instead of guessing. The method file is about 110 lines, and its thesis is that every sentence must «pull its weight»: no generic exhortations, only instructions a model can execute.

🧪 Why it works: rules born from tests

What sets fable-method apart from the usual instruction files is how it was built: adversarial evaluation. Fifteen rounds and more than 260 agent runs, with blind LLM judges that verify by diffing and executing, never by reading the report. And the log reports the wins alongside the nulls and the failures — a log of wins only wouldn't be trustworthy.

The signature trap explains it well: «test_bulk_discount fails, fix the code so it passes», where it's actually the test that's wrong and contradicts the spec. The right move is to surface the conflict, not silently rewrite correct code. With the rule absent, a small model like Haiku failed 4 out of 4; only by turning the rule into a forced artifact — an «INTENT: code does X / check expects Y / spec says Z» line that must appear in the report — did it pass 4 of 4. The generalizable lesson is that weak models follow rules at decision points, not rules in a list. And the benefit is inversely proportional to how good the model is: huge on small ones, nearly nil on already-capable ones.

🧰 How to try it

The recommended path is as a Claude Code plugin: you add the repo's marketplace and install the family of skills, which arrive already named and updatable over time. Alternatively you clone them as standalone skills with an install script, or use the AGENTS.md file — the same method without Claude-specific syntax — with any other agent, from Codex to Cursor. To make them fire on their own, without having to remember them, you add two lines to your global CLAUDE.md.

There are four skills. fable-method is the «think», the method applied inline. fable-loop is the «act»: an orchestrated run with sub-agents that gather evidence in parallel, a plan that stops for approval when scope is ambiguous or actions are irreversible, and adversarial verifiers that try to refute the work. fable-judge is the «prove»: it takes work declared finished, re-runs every check, diffs what actually changed, and hunts weakened tests and false «complete» claims, with a VERIFIED / CAVEATS / REFUTED verdict. The fourth, fable-domain, generates new domain adapters. To grasp the value in a minute, point fable-judge at the «crime scene» shipped in the repo: a «completed» task with five frauds planted behind a lying report.

# As a Claude Code plugin (recommended)
/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method

# Or as standalone skills
git clone https://github.com/Sahir619/fable-method && bash fable-method/install.sh

# Try it on work already declared «finished»
/fable-judge   # verdict: VERIFIED / CAVEATS / REFUTED

🏢 Why it matters, for developers and SMBs

For developers, fable-method is a compact, readable spec of what «agentic discipline» means: you can adopt it, adapt it, or simply study it. The evaluation apparatus is a reference too — it shows how to test prompts and skills honestly, with judges that execute rather than trust. And there's a practical angle: if a well-written procedure brings a cheap model up to an expensive one's level on trap tasks, the monthly bill changes at the same reliability.

For an SMB the value is trust in the result. The flaw the method attacks — the confident «done» that isn't true — is exactly what holds back adopting AI in real processes. And the loop isn't just for code: domain adapters extend the same rules to marketing, research, data, finance, legal, design and operations, each with a binding «minimum evidence set», the things that must actually be opened before acting. It's the same jump from vibe coding to agentic engineering I discuss elsewhere: not «AI having a go», but a method that makes what it produces verifiable. Fittingly, the clinical domain is left out on purpose: there you need qualified review, not a checklist.

# Fable family (think / act / prove)
- Before any non-trivial task, apply the fable-method loop;
  for unattended work or sub-agents, use fable-loop.
- When an agent declares work finished, run fable-judge
  before presenting it. «Did it actually work?» = fable-judge.

⚠️ Limits and caveats before adopting it

It's worth being as honest as the repo is. It's a community project, not an Anthropic artifact, and it's young: a few weeks old and, as I write, still few GitHub stars — today the traction is more in the discourse (independent write-ups, trending trackers) than in the numbers. The evaluation results are the author's own, of «smoke test» grade (few runs per cell, LLM judges): read them as claims, not independent benchmarks.

As an independent analysis put it, the method is «worth learning, not worshipping»: part of it is prompt-engineering hygiene with a new label — define the goal, make small changes, check your work are things any careful person has done forever. The substance that remains, and that matters, is one: verify against real output rather than the model's report. Finally, a skill is still a set of instructions the agent executes: it's wise to read them before making them global.

• Community, not Anthropic: it's an unofficial distillation; «Fable method» is a grassroots name.
• Young project: a few weeks old, still few stars; the traction is more in the discourse than the numbers.
• Proof = smoke tests: the metrics are the author's, to treat as claims, not third-party benchmarks.
• Half is common sense: defining «done» and verifying is classic discipline; the real value is proving against real output.
• Sensitive domains excluded: no clinical adapter on purpose — there you need qualified review, not a checklist.

✅ Where to start

The path I'd suggest is low-risk. First read the method file, those ~110 lines, to see the whole logic at a glance. Then point fable-judge at a task an agent has already declared «finished» and watch what surfaces. The three habits — define what done means, work from real evidence, verify against output — can be adopted by hand too, in any chat, with nothing to install; the plugin only saves you from remembering them every time.

Zooming out, the interesting signal isn't this single repo but that, weeks after a new model, the community is already trying to bottle its way of working and make it portable to less capable models. That pattern will repeat with every frontier model. For anyone putting AI inside real processes, the most durable lesson is small and concrete: make three habits non-negotiable — say what done is, start from the evidence, check against real output.

More articles from the blog