The Five Skills Fable Wrote Before It Left
Five manuals from the smartest model Anthropic have shipped — installed in one paste, followed by every model after
The Idea
Think of Fable like the smartest consultant your business has ever had — and they leave Tuesday. You don't spend their last two days asking them more questions. You get them writing the manuals: how they'd do the jobs you'll still need doing after they've gone.
In Claude, a manual is called a skill: a file where the model writes down exactly how it does a job — when to start it, the method, what good looks like, when not to trust itself. Skills trigger themselves: once one is installed, you just say the job ("is this safe to ship?") and Claude reaches for the manual. No prompt to remember, no command to learn.
So that's what this page is: the five manuals I had Fable write before its window closed, checked and tested, installable in one paste. Whatever model your sessions run on next month, these jobs get done the way the smartest one would have done them.
Install All Five in One Paste
Open Claude Code in your project and paste this. It fetches the skills from GitHub, puts them where Claude looks for them, and shows you what will trigger each one. No terminal needed.
The Five
Only want one? Each card carries its own paste — it installs just that skill and puts it straight to work.
The Security Sweep
security-sweepSay: "is this safe to ship?"
Checks everything you're about to ship the way a security reviewer would — tuned to the holes vibe-coded apps actually get hacked through: keys reachable from the browser, routes that trust the client, the ID-swap trick, wide-open database rules, unverified payment webhooks.
You walk away with: A ranked list of what an attacker could genuinely do, each one a plain-English sentence with the exact line of code, and an offer to fix them worst-first.
The honest limit: It's a careful read of your code, not a penetration test — for anything holding other people's money, get a professional too.
The Setup
project-setupSay: "new project — set it up properly"
The first hour of a new project, done right: version control before the first mistake, secrets out of the code before the first key exists, a CLAUDE.md written at birth, and the thinnest possible version deployed live before any feature gets built.
You walk away with: A live URL and foundations that make month two boring — no lost work, no leaked keys, no launch-day deployment crisis.
The honest limit: Tuned for small web products — a mobile app or data pipeline changes the checklist, and it says so rather than forcing this one.
The Build Planner
build-plannerSay: "plan out how to build this"
Turns "I want to build X" into a staged, written plan: asks the questions that change the build, offers real options with trade-offs, then slices the work into stages that each end with something you can see working. The smartest model thinks once; everything after just executes.
You walk away with: A PLAN.md where every step carries its own verification and its own scope fence — ready to hand to a cheaper model or a future session that remembers nothing.
The honest limit: A plan is a hypothesis — it lowers the intelligence needed to execute, it doesn't remove it.
The Honest Advisor
honest-advisorSay: "poke holes in this idea"
Stress-tests your business idea with the yes-man switched off. Steelmans it first so the critique isn't lazy, then attacks: who actually pays, the one number everything hangs on, why you, and the cheapest real-world test that could kill it.
You walk away with: A straight verdict — do it, test it first, or drop it — plus what would change its mind. And it holds the position when you push back, unless you bring new information.
The honest limit: Over a long friendly chat any model drifts back to agreeing with you — when it matters, re-run it fresh instead of arguing until it caves.
The Bug Hunter
bug-hunterSay: "you said it was fixed and it isn't"
Hunts a bug the way a senior debugger would — and refuses the move that ruins most debugging sessions: guessing a fix. It isn't allowed to touch code until the failure is reproduced on demand. Then it reads what the error actually says, tests one hypothesis at a time, and fixes the cause, never the symptom.
You walk away with: The bug actually fixed, with proof — the exact case that failed now passes — plus the cause explained in one sentence and a check for the same mistake elsewhere in your code.
The honest limit: When three hypotheses die in a row it stops and packages the evidence for a smarter model, instead of thrashing your codebase.
The Handover Format
Fable designed one structure for its own handover, and all five manuals follow it:
The last section is the one to notice. Every skill ends by telling you when not to trust it — the sweep says it isn't a penetration test, the advisor admits it will eventually cave if you argue long enough, the planner calls its own plan a hypothesis. A manual that knows its limits is worth ten that don't, and it's the part most shared skills skip.
Then Commission Your Own
The five cover the jobs most builders repeat. The personal ones — your writing voice, your report format, the weekly job only your business has — can't be pre-written, and you shouldn't write them by hand either. This prompt has the smartest model you can reach interview you about a job you repeat, do it once with your corrections, and write the manual in the same handover format.
The habit that makes this compound: any time the model does a job exactly how you wanted, say "save this as a skill" before the session ends. The corrections are still in the conversation, and the skill inherits them for free.
Grab all five from GitHub.
The five skills, the install prompt, and the commission prompt live in one repo — so Claude can fetch them and you can fork them.
View the skills on GitHubThe other half of the handover
Skills are how the model does jobs. The Three Tiers of CLAUDE.md is how it thinks — the standing orders it reads before every prompt. Have the smartest model write both before its window closes, and you've kept the two things about it that were worth keeping.
The Honest Bit
A skill holds a method, not intelligence. The genuinely hard calls — the novel bug, the judgment under real uncertainty — still need a good model, and no file changes that. But be honest about how much of your week is method: the checks, the setups, the structures, the standards. That part writes down. That's the part you keep.