Fable 5 Told Me to Tear the Guardrails Off My Favorite 121k-Star Skill. Are Skills Dying?

Hours after Anthropic shipped Fable 5, the first thing I did wasn't coding. I read the release notes and the prompting guide, end to end.

One line stopped me cold.

The official guidance says: skills developed for prior models are often "too prescriptive" for Fable 5 — and can degrade output quality. And elsewhere: prefer general instructions over prescriptive steps, because "Claude's reasoning frequently exceeds what a human would prescribe."

In plain words: with a model this smart, tell it the outcome you want. The more you spell out the process, the worse it performs.

That sentence hit something I'd never quite put in focus.

I thought of Superpowers.

If you're not deep in the AI-coding world: Superpowers is the hottest open-source skill framework of the year. Accepted into the official Claude plugin marketplace in January. Past 121k GitHub stars by April — one of the fastest-growing open-source projects of 2026. And for me personally it ranked even higher: it was my single favorite plugin of the Opus 4.6 / 4.8 era. It pushed my whole project through TDD — write the tests, then the implementation, verify before declaring done. My code routinely passed on the first run. It easily saved me multiples of my time.

But under the light of that one official sentence, I also remembered what's written inside it, and inside several other plugins I run: walls of "YOU MUST", "NOT NEGOTIABLE", and the famous rule — if there's even a 1% chance a skill applies, you must invoke it.

All of that was written for an older model — one that got lazy, skipped steps, claimed "done" without checking. Is the thing sitting at the desk today still that intern who needs to be yelled at?

So I asked Fable 5 directly.

Its answer was blunt: the heavy negative constraints and threatening tone written to keep older models in line genuinely interfere with how it works. Then it handed me a self-audit prompt to scan every skill I have installed.

Here it is, verbatim. Copy it and run it on your own project:

Review this project's CLAUDE.md and all skills / custom instruction files.
Goal: modernize and slim them down for Fable 5.

1. List every instruction that asks the model to "show your thinking /
   explain your reasoning" — recommend deletion.
2. Flag overly prescriptive step-by-step instructions (operation
   checklists, over-specified format rules) — these were written for
   older models and may now degrade your output quality.
3. Keep: project background, tech-stack constraints, documentation
   priority rules, explicit prohibitions.

Give me a delete / keep / rewrite list first. Do not change any files
until I confirm.

The scan came back. The worst offender was Superpowers' dispatch layer — the part injected into every single session. The findings, item by item:

An <EXTREMELY-IMPORTANT> block shouting in all caps: "IF A SKILL APPLIES… YOU DO NOT HAVE A CHOICE. THIS IS NOT NEGOTIABLE."
The 1% rule — a mandatory ritual before even asking a clarifying question.
An entire flowchart dictating its response order.
A 12-row "Red Flags" table that classifies the model's normal judgment ("let me look at the code first") as rationalization.

Its verdict: this is counterproductive for it — it fights the system prompt, forces a skill check before trivial Q&A, and burns injection cost every session. One line stuck with me:

"For the old models this conflict was a guardrail. For me it's noise. I absorb most of the coercive language with my own judgment, so the damage is limited — but it puts pointless pressure on every session."

What it proposed was even more interesting. The enforcement turned out to be stacked three times over: the plugin hook injects once, the injected text re-asserts itself, and CLAUDE.md presses it a third time. The recommended fix was tiny: delete the one redundant line in CLAUDE.md. Plugin behavior unchanged. It never told me to uninstall Superpowers — the 121k-star framework is still installed. Its overall judgment: "a dragging dispatch layer plus a set of genuinely valuable workflows — benefits outweigh the drag, keep it."

I confirmed. It executed. That afternoon, the untied Fable 5 ran better than before.

Sit with that contrast for a second: my most-recommended plugin's proudest mechanism — mandatory enforcement — is now, in the new model's own words, "noise." Which raises the real question: all these rules we've been writing for AI — were they helping it, or holding it back?

Every skill has always been two things: procedures, and intel

Take any skill apart and you'll find two very different ingredients.

The first is procedures. They cut both ways: what you must do — brainstorm before coding, think step by step, verify before declaring done — and what you must never do — never skip steps, never commit without tests — all backed by a threatening tone. It's a recipe-plus-kitchen-rules sheet written for an apprentice cook: three grams of salt, scallions before meat, never use high heat, never plate without tasting. The only reason it exists is that the apprentice can't be trusted.

The second is intel. When a Michelin chef walks into your kitchen for the first time, you don't teach him to cook. But there are things you must tell him: the kid is allergic to peanuts, grandma needs it stewed soft, your stove runs hot, the soy sauce is low-sodium. That's not instruction — that's information only you have and he could never deduce. In a project, it's your conventions, your code standards, the API whose egress IP rotates between two data centers, your taste.

The real shift in the Fable 5 era is one sentence: procedures are turning into liabilities at scale; intel is appreciating.

Why does over-prescription degrade quality instead of just wasting tokens? Because a procedure pins the model to a path designed for someone weaker. An apprentice following the recipe is protected from failure; a master chef following the recipe is locked out of everything he knows. Note that "must do" and "must not" are equally guilty here — mandatory step-by-step thinking is just as much a cage as any prohibition, because the model may have a better path than the one you wrote down.

Roll call: which famous skills are obsolete

Superpowers: a dragging dispatch layer + genuinely valuable workflows. That's Fable 5's own breakdown, and it maps exactly onto procedures vs intel. The dispatch layer is pure procedure — and its design philosophy made total sense once. The author, Jesse Vincent, has a famous smoke test: open a coding agent, type "let's make a React todo list" — if it starts writing code, I've failed; if it kicks off brainstorming, the right thing happened. Correct for old models, which never paused to think. But Fable 5 already investigates and scopes ambiguous tasks on its own; forcing the full ritual is making a PhD show their arithmetic in long division. Notably, the author is dismantling it himself: the 5.1 release deleted deprecated commands and "old boilerplate that didn't improve outcomes." Meanwhile the workflow content — TDD, writing-plans, subagent-driven development, code review — is, in Fable 5's words, "not crutches for the model; they're this project's established engineering process." Plus an underrated layer: shared process vocabulary. I say "run this subagent-driven" and it knows exactly what I mean. Same plugin: procedures retiring, standards and vocabulary staying.

Over-prescriptive "positive demands" get hit too. My scan flagged a documentation skill demanding user-story lists be "extremely long, covering all aspects." Fable 5's annotation: "longer = more complete" is an old-model prompting trick that now just produces padded user stories. Suggested rewrite: "cover all user-facing aspects; omit redundant variations."

Anti-fake-completion skills (verification-before-completion): be fair here. The failure mode they target — claiming "fixed" without running the tests — still exists on strong models. The idea isn't obsolete at all; the mandatory ritual wrapped around it is. One official line — "audit each claim against a tool result before reporting" — now does the work of an entire skill. The idea won; the vehicle retired.

Show-your-thinking skills: not obsolete — actively harmful. On Fable 5, instructions to reproduce internal reasoning in the response can trigger reasoning-extraction refusals and fall the request back to an older model. You may have noticed: it's item #1 in the audit prompt above. This is the one category I'd clean out today.

Multi-agent orchestration frameworks (agent-to-agent and friends): the most fully absorbed. The intricate role definitions, message protocols, turn-taking — Fable 5 does most of it natively, dispatching parallel subagents and managing long-running peers. The official docs now warn about over-dispatching. But one thing was not absorbed: the boundaries. What can be delegated, what permissions a subagent gets, where a human signs off — execution got internalized; governance is still yours.

What's appreciating: pure-intel skills. Anthropic's own docx/pptx skills are nothing but library quirks and rendering traps — things no model can know from thin air. Your style guides, your taste files, your hard prohibitions. And memory systems — the one category the official docs explicitly say Fable 5 performs notably better with. Upgraded by the new model, not deprecated.

How to write skills now: four principles

Skills won't disappear, but the genre is changing — from program to intel. Concretely:

Declarative, not procedural. Write what done looks like, what's unacceptable, what the constraints are. Leave the how to the model; you own the what and the why.
Principles over enumeration. The official finding: one short principled instruction performs as well as enumerating every behavior. Ten rules become one sentence.
Knowledge density is the only moat. A skill's value equals the amount of information the model could not derive on its own: environment traps, domain dark knowledge, your taste, your org's conventions. Skills that merely discipline the model are going to zero.
Let the model co-maintain. Fable 5 is good at updating skills on the fly from what it learns mid-task. Skills are becoming living documents you maintain together — converging, eventually, with memory.

The long view: what gets swallowed, what never will

Will skills die? Draw one hard line first.

Model capability comes from training; training comes from data. So: any general capability learnable from public data will eventually be absorbed into the model. Anything private, local, contingent, or preference-shaped can never be absorbed by pretraining — not because the model is weak, but because that information isn't in its distribution. Your architecture decisions, your aesthetics, your partner agreements — the strongest model can only be told, never learn them.

So skills won't die. They're evaporating: the general-methodology part keeps boiling off into the model, and the residue gets purer — pure private knowledge, intent, and norms. I watched it happen this week: "brainstorm before coding" and "verify before done" evaporated out of Superpowers; "what makes a good unit decomposition" and my project's specific conventions stayed.

And the absorption isn't an accident — it's an institutionalized pipeline. "Think step by step" was a community incantation; it became native reasoning. Reflection tricks became native verification. Community orchestration frameworks became native subagent scheduling. Model vendors watch what the skill ecosystem uses at scale, then train the validated consensus into the next generation.

Which means the skill ecosystem isn't competing with models — it's their R&D outpost. A skill is the cheapest possible way (text) for users to express "I wish the model did this by default," and vendors harvest the consensus. Being absorbed isn't failure; it's a skill's greatest success — the way lodash got absorbed into ES6, the way jQuery died of browser APIs maturing. Libraries as a species never disappeared; they climbed to higher layers of abstraction. Skills will do the same: behavior absorbed, then up to the knowledge layer, the intent layer, the governance layer.

A few years out, I'd bet "skill" stops being a separate category and fuses with three things: memory (model-maintained lesson files — the line between human docs and model notes disappears), identity (when what's left is taste, norms, and value rankings, a skill defines who the agent is and whose standards it works by — the ultimate form of a skill is an agent's soul file), and protocol (knowledge injection will standardize the way tool-calling did with MCP — portable across models). That last one is the strongest guarantee skills survive independently: base models will be swapped — Fable today, someone else tomorrow — but your accumulated knowledge layer shouldn't be locked to any vendor. The model is a replaceable engine; the skill layer is a non-replaceable asset. That's economics, not technology.

Two cold showers

Before you go delete everything:

First, don't overcorrect to zero instructions. The official docs still recommend explicit boundary statements, evidence audits, periodic verification. Fable 5 doesn't need no rules — it needs fewer, more principled rules. You're removing the recipe, not the sentence "the kid is allergic to peanuts." And the more autonomous the model, the more non-negotiable your authority boundaries become. When Fable 5 told me to cut Superpowers' enforcement line, it never suggested touching my "confirm with me before publishing" gate. That distinction is worth sitting with.

Second, an engineering reality: Fable 5 ships with safety classifiers, and certain requests automatically fall back to Opus 4.8 — exactly the model that needs detailed instructions. Delete every procedure and your fallbacks run naked. The robust move: compress core discipline into a few short principles in CLAUDE.md (both generations benefit), and archive the detailed procedural content instead of deleting it.

What's left at the limit

Push the thought experiment to the end: if model capability were infinite, what remains of skills?

What remains is what you want.

Capability answers can. Skills ultimately carry want and should — preference, authorization, responsibility. Those live structurally on the human side; a stronger model can only understand them better, never own them for you. And the more autonomous the model, the higher the leverage of stating intent clearly — for an agent that works a week unsupervised, the intent document you write before it starts is worth a hundred times what it was.

So, laid out plainly: short term (a year or two), behavior-correction skills depreciate fast, knowledge skills appreciate, the ecosystem reshuffles. Mid term, skills fuse with memory and identity systems and standardize into a cross-model private knowledge layer. Long term, they converge into containers of intent and norms — smaller and smaller in volume, higher and higher in unit value, permanently independent.

In the end, models and skills answer different questions. The model answers "can it be done" — and capability will keep answering that for you. Skills carry "what do you want, and what should happen" — and that question has only ever had one person who can answer it.

Progress won't make the second question disappear. It will only make it more valuable.

One action before you close this tab: copy the audit prompt above and run it on your own project. Those old-model constraints may be quietly capping what Fable 5 can do for you. I was genuinely startled by my own scan — beyond Superpowers, even my UI/UX prompt skills were full of outdated cruft.

You don't know until you scan. The cleaner the scan, the faster the run.

Go look: how much of your skill library is still standing in Fable 5's way?