fable-method Review: What's Actually Worth Keeping

I was one click from installing it. A skill for Claude Code with a promise that stopped me mid-scroll: it claimed to bottle up how Claude's Fable 5 model worked — "written down before it was gone." I collect shiny objects for a living. This was catnip.

Then twenty years of working in banking kicked in. In banking you learn fast that everyone wants what's best for you — namely, your money. So instead of clicking install, I took the thing apart on the workbench first.

Vetted

One evening

License

MIT, free

What I kept

1 of 3 parts

Score

4/10

That's the short version. Below: how I checked a skill without running it, the moment its own eval gives the game away, the one part I rebuilt and kept — and what happened when I pointed that keeper at 96 tools I'd already published.

What fable-method actually is — and what it claims

fable-method is a free, open-source plugin for Claude Code by a developer called Sahir619 (not Anthropic — worth saying, because the name implies otherwise). It bundles three skills: one to think through a task, one to act on it, one to prove the work is done. The pitch is that this bottles the working style of one specific Claude model — Fable 5, which keeps flickering on and off the market, so "before it's gone" is a moving target.

Here's the thing it doesn't say out loud. Strip the name off and what's left is a generic checklist any decent AI prompt already half-does: classify the task, define what "done" means, gather evidence, decide, change things surgically, verify, report the outcome first. Sensible. Also not a secret, and definitely not a dead model's brain in a bottle.

"Preserves how the model thought" is a story. A 7-step checklist with a famous name on it is what's in the box.

How I checked it — without installing it

A skill is two things at once: code that runs on your machine, and instructions that steer your AI. Both can bite you. So I looked at both, in this order — and this is the part you can copy for any skill you're tempted by.

First, the install script, in raw text. Not the tidy summary a fetch tool gives you — the actual install.sh, read line by line. (Lesson I nearly learned the hard way: my fetch tool summarises instead of quoting. When you're trying to see what a script really does, a summary is worthless — you need the literal text.) What I read was a plain local copy — files moved into a folder, no downloads, no remote code that I could see. Emphasis on I could see: your machine, your call. More on that near the end.

Then the substance, adversarially. I didn't ask "what does this do?" — you always get a flattering answer. I set three checkers loose in parallel, each told to disprove the skill, not retell it: one on the method, one on the act/prove parts, one on the bundled eval. Retelling makes marketing sound true. Trying to break it is how you find out what's real.

What its own eval actually admits

The best part of this skill is that it ships with its own test results. And if you read them against the headline instead of nodding along, they tell a different story than the pitch does. All numbers below are self-reported, in the repo's eval/ folder — I'm taking them at face value, because they're refreshingly unflattering:

• On the very first scenario, the plain baseline scored 8.0 and the method scored 7.5. The method made it slightly worse.
• It only "won" a later scenario after being tuned three times against that exact scenario — which is testing on the answer sheet.
• On a strong model, the baseline already nailed the traps on its own. The method had almost nothing left to add.
• Two whole rounds came back 12-out-of-12 identical in both conditions. A pure zero.
• On a knowledge task, a weak model plus the method scored 3/10; a strong model with nothing scored 10/10.

The authors say it themselves, and to their credit they say it plainly: the method "supplies discipline, not knowledge." Which lands you on the real punchline:

The stronger your model, the less a discipline skill does for you — and models only ever get stronger. It helps most exactly where you need it least.

The one part I kept — the judge

One of the three parts survived the teardown: the judge. Its job is narrow and honest — take "I'm done, I tested it, it's green" as a claim, not a fact, and check it against the diff — the actual line-by-line changes in the files — not against the story the AI told about its work. It even names the ways an AI fakes "done": weakened tests, false completion, quietly betraying the spec, scope creep, leftover debris.

But the original has a flaw: it lets the same AI, in the same session, grade its own homework. Same blind spots, same incentive to wave it through. So I didn't install the plugin. I rebuilt just this part as my own small /judge skill and fixed the flaw: the check runs in a fresh, separate agent that only sees what changed and what was claimed — never how or why the work was done. Isolation instead of self-grading. Here's the whole idea, small enough to paste into your own AI:

✦ Prompt to steal any AI Copy

Treat this "done" as a set of claims, not a fact.
The diff — what actually changed in the files — is ground truth; the report is not.
Re-run every claimed check yourself — don't read code and nod.
Hunt: weakened tests, false "done", spec betrayal, scope creep, debris.
Verdict: VERIFIED / VERIFIED WITH CAVEATS / REFUTED — evidence first.

Want the full thing? The complete /judge skill — the one I actually run — lives on GitHub, MIT-licensed. Take it, read it, drop it into your own setup: github.com/giftedprocrastinator/judge-skill. It's the prompt above, wired to spin up that isolated checker for you.

Then I pointed /judge at 96 of my own tools

Here's where a keeper earns its place: not in a demo, but on your own work. The CS Lab on this site is a pile of interactive tools I had an AI build so I could learn computer-science concepts faster. They look good. They run. Whether every one is actually correct — I genuinely couldn't tell you. I'm not deep enough in the material to catch a confident, well-formatted lie, and confident well-formatted lies are exactly what these models produce.

So the day after the teardown, I set /judge loose on all 96 — a blind first pass, then an adversarial second pass on everything it flagged. The result was humbling: my proud "verified 96 of 96" held up structurally, but not factually. It surfaced 19 genuine critical errors across 12 tools — wrong explanations or wrong tool logic — plus a long tail of smaller stuff. All 12, fixed at the source.

And — this is the important half — the judge is a suspect-detector, not an oracle. It flagged things that turned out to be fine, and I checked each one instead of trusting the machine that distrusts the machine. One "bug" in a tokenizer was a false alarm: an invisible separator character that merely looked like an empty string. Ten more of its flags didn't survive a closer look either. That's not the judge failing. That's the whole point:

A tool that distrusts your AI still has to be distrusted. It hands you a list of suspects — you're still the one who checks the alibis.

Credit where it's due

None of this is a hit piece. The developer did something most don't: shipped the receipts and let them show the losses. The reason you can even see that the method barely helps a strong model is that he measured it fairly and published the parts that make his own tool look ordinary. That's rare, and it's decent. The verdict isn't "he's lying." It's the quieter, more useful one:

Marketing is never proof. A bundled, honest eval — read against its own headline — sometimes is. The social-media bling told me to install. The eval told me to keep one-third and walk. The eval was right.

So — how do you actually find out whether a skill is safe to run, before you trust it? That's exactly the right question to be asking. It's a whole post of its own: how to vet an AI skill before you install it.

Trust, but verify — then verify the verifier. ✦

From now on /judge runs on every "it's done" an AI hands me. The other two-thirds are still not installed, and I don't miss them. The tools it saved live in the CS Lab.