What These Skills Are and Why They Exist
Source:
github.com/kpab/claude-fable-5-skills
Author: kpab (MIT)
Shipped: July 2, 2026. Listed in awesome-claude-code issue #2164.
Install:
/plugin marketplace add kpab/claude-fable-5-skills
/plugin install fable5-skills@claude-fable-5-skills
Or manual:
git clone https://github.com/kpab/claude-fable-5-skills
cp -r claude-fable-5-skills/skills/act-when-ready ~/.claude/skills/
# cherry-pick individual skills, or copy all 10
Works with: Claude Code, Claude Cowork, Cursor, Copilot, Gemini CLI, and any harness that reads SKILL.md files.
The problem these skills solve
Anthropic's own Fable 5 prompting guide states directly: skills written for older models are often too prescriptive for Fable 5 and can degrade output quality.
Older skills micromanage. They specify step-by-step procedures because previous models needed hand-holding through tasks. Fable 5 does not. It follows instructions strictly and accurately. When you give it a recipe, it follows the recipe even when the recipe is suboptimal for the task. This is a different failure mode from older models and it requires a different kind of skill design.
The fix: state the outcome you want and the boundary you are enforcing. Not the steps. The model works out the steps. Skills written this way are shorter, more reliable, and actually improve Fable 5 output rather than constraining it.
Three patterns old skills get wrong that this collection fixes:
- Capability compensation: instructions that exist to overcome limitations Fable 5 no longer has
- Over-planning scaffolding: prompts that ask the model to think aloud when it can just act
- Procedure substitution for guardrails: multi-step recipes instead of simple outcome + boundary rules
4 design principles applied to all 10 skills
- Intent over procedure. Fable 5 follows instructions strictly. State outcomes and boundaries, not step-by-step recipes.
- Short by construction. Every skill fits on one screen. If a line does not change behaviour, it is deleted.
- Verification hooks, not vibes. Where correctness matters, the skill defines a check (evidence rule, turn-ending check, diff self-check), not an exhortation to "be careful".
- Original text. All instruction text is written from scratch, informed by Anthropic's public Fable 5 prompting guide and direct testing.
The 10 skills at a glance
| Skill | What it fixes |
|---|---|
| skill-refactorer | Audits your pre-Fable-5 skills and deletes capability-compensation scaffolding |
| act-when-ready | Over-planning: re-deriving settled facts, surveying options it won't pursue |
| effort-calibrator | Picking the right effort level per workload |
| no-gold-plating | Diffs bigger than the ask: unrequested refactors, speculative abstractions |
| grounded-progress | Status reports must point at tool-result evidence, not narrate invented states |
| scope-guard | "Diagnose" ≠ "fix". No unrequested actions, no state changes on pattern-matched evidence |
| subagent-orchestration | Parallel delegation, long-lived workers, fresh-context verifier subagents |
| markdown-memory | File-based lesson memory with the maintenance discipline that keeps it useful |
| autonomous-continuation | Unattended runs that stall on "I'll now run X" or mid-run permission questions |
| regrounding-summary | Final reports readable by someone who saw none of the work |
Skill 1: skill-refactorer (The Meta-Skill)
The meta-skill. Reads any existing skill or prompt file and rewrites it to be Fable 5-native: deletes capability-compensation scaffolding, keeps real guardrails, converts step-by-step procedures into outcome + boundary rules.
Run this on your existing CLAUDE.md, skill files, and system prompts before anything else in this collection.
What it does
Capability-compensation scaffolding is instruction text that exists to patch around weaknesses older models had. Examples:
- "Think step by step before answering" (Fable 5 does this without being told)
- "Make sure to verify your output" (Fable 5 self-checks without prompting)
- Multi-step procedures for tasks that are now single-step for Fable 5
- Explicit tool-calling sequences that the model now figures out automatically
The skill-refactorer identifies this scaffolding and removes it. What survives: actual guardrails (scope limits, output constraints, evidence requirements), domain knowledge the model genuinely needs, and verification hooks.
Copy-paste prompts
"Run skill-refactorer on this skill file: [PASTE SKILL.md CONTENT or PROVIDE FILE PATH]
For each section of the skill:
1. Is this instruction compensating for a capability gap Fable 5 no longer has?
2. Is this a procedure that could be replaced with an outcome + boundary statement?
3. Does this line change behaviour, or is it encouragement?
Delete capability compensation. Convert procedures to intent + boundary. Keep real guardrails.
Output the refactored skill and a diff showing what was removed and why."
"Run skill-refactorer on my CLAUDE.md.
File path: CLAUDE.md
Flag anything that:
- Asks the model to think aloud when it should just act
- Specifies steps for tasks Fable 5 handles natively
- Uses exhortations ('be careful', 'make sure') instead of checks
Produce the refactored version and an audit log of deletions."
Skill 2: act-when-ready
Fixes over-planning at high effort levels. At xhigh or high effort, Fable 5 can re-derive facts that are already settled, survey options it will never pursue, or present a planning summary before acting on a task that is already clear. act-when-ready prevents this.
What it does
Act-when-ready defines the threshold for action: when the task is clear and the information needed is present, execute rather than plan. The skill draws a specific line between cases where planning has value (genuinely ambiguous requirements, multi-team dependencies, irreversible actions) and cases where it is just delay.
Fable 5 at high effort has a specific failure mode: it can treat planning as a deliverable. This skill makes execution the deliverable and planning a tool used only when needed.
Copy-paste prompts
"Load act-when-ready skill.
Task: [DESCRIBE YOUR MULTI-STEP CODING OR AGENTIC TASK]
Start executing once you have enough information.
Do not re-derive facts that are already clear from this prompt.
Do not present options you will not pursue.
If something is genuinely ambiguous, ask one question before acting."
Verification test from the repo:
"Install act-when-ready and give Claude Code a multi-step but already-clear coding task.
With act-when-ready active, it should begin executing once it has enough information rather than
re-deriving already-established facts or presenting a menu of options it would not pursue."
Skill 3: effort-calibrator
Fable 5 at medium effort often beats older models at maximum effort. Most teams do not know this and pay more than they need to while getting worse results from over-thinking. effort-calibrator sets the right effort level per workload type.
What it does
Effort levels available in Fable 5: low, medium, high, xhigh.
The skill defines a calibration table: which workload types warrant which effort level. The core insight is that high effort does not uniformly improve results. For many tasks (straightforward code edits, well-specified feature additions, clear bug fixes), medium effort produces better output because it acts rather than over-plans.
High and xhigh effort are reserved for genuinely hard tasks: novel algorithmic problems, complex multi-system debugging, architecture decisions with real ambiguity.
From the repo author: "Fable 5 at medium often beats older models at max."
Effort level guidance
| Effort | Use for |
|---|---|
| low | Simple tasks, quick queries, basic formatting, obvious fixes |
| medium | Most coding and agentic work (the default for Fable 5) |
| high | Complex multi-step reasoning, hard debugging, multi-system tasks |
| xhigh | Maximum capability, genuinely novel problems, architecture |
Key rule from the skill: most coding and agentic work runs at medium. Move to high only when medium produces incomplete or incorrect results on the specific task.
Copy-paste prompts
"Load effort-calibrator skill.
Task: [DESCRIBE TASK]
What effort level does this task warrant and why?
Then execute at that effort level."
"Load effort-calibrator skill.
I have been running everything at xhigh. Audit my last 5 tasks and tell me which ones should have run at medium or low instead. For each one, explain what the appropriate effort level is."
Config:
{
"model": "claude-fable-5",
"effort": "medium" // default for most GTM and coding work
}
Skill 4: no-gold-plating
Fixes diffs bigger than the ask. Fable 5 can produce unrequested refactors, speculative abstractions, and error handling for states that cannot actually occur. no-gold-plating enforces a direct relationship between the ask and the change.
What it does
The skill defines a diff self-check that runs before output: does the change touch only the lines needed to satisfy the ask? If it touches more, the additional changes require explicit justification against the ask.
Patterns it specifically blocks:
- Unrequested refactors of code adjacent to the fix
- Speculative abstractions ("I added an interface in case you want to swap implementations later")
- Error handling for states the application cannot reach
- Dependency additions not required by the asked-for change
- Renaming or reformatting outside the scope of the fix
Copy-paste prompts
"Load no-gold-plating skill.
Fix this specific bug: [DESCRIBE BUG]
File: [FILE PATH]
The diff should touch only the lines needed to fix this bug.
No adjacent refactors, no speculative abstractions, no added error handling for impossible states.
If you see something else that should be fixed, note it separately but do not change it."
"Load no-gold-plating skill.
Add this feature: [DESCRIBE FEATURE]
Before submitting your diff, run the self-check:
- Does every changed line directly serve the feature as described?
- Did I add anything the ask did not require?
If yes to the second question, remove it or flag it for explicit approval."
Verification test from the repo:
"Install no-gold-plating and ask Claude Code to fix a small, well-defined bug in an existing file.
The resulting diff should touch only the lines needed to fix the bug,
with no added abstractions, error handling for impossible states, or unrelated refactors."
Skill 5: grounded-progress
Status reports on long runs must be grounded in tool-result evidence. Without this skill, Fable 5 can report "tests passing" or "migration complete" when those operations were never run. grounded-progress requires evidence before any status claim.
What it does
The skill defines an evidence rule: every status claim in a progress report must point to a specific tool result that supports it. "Tests passing" requires a tool output showing the test results. "Migration complete" requires a tool output confirming the final state.
This is a verification hook, not an exhortation. The instruction is not "make sure you verify your claims." It is "every status claim must cite a tool result by name and line reference."
The failure mode it prevents: Fable 5 on long unattended runs can synthesise a plausible-sounding summary of work it did not fully complete. This is not hallucination in the usual sense. It is confident interpolation from partial evidence. grounded-progress requires the evidence to be explicit.
Copy-paste prompts
"Load grounded-progress skill.
Run this multi-step task: [DESCRIBE TASK]
After each major step, report progress.
Every status claim must cite the tool result that supports it.
Do not report a step as complete unless you have run the verification tool and received confirmation output.
If a step failed or produced no output, say so."
"Load grounded-progress skill.
You said the tests are passing. Before continuing:
Cite the specific tool result that shows this.
What command did you run? What was the output?
If you have not run the tests, run them now before reporting status."
Skill 6: scope-guard
Diagnose does not mean fix. scope-guard enforces the boundary between observation and action. Without it, Fable 5 can infer a problem from pattern-matched evidence and take action to fix it before that action was authorised.
What it does
The skill defines a hard boundary: pattern-matched evidence of a problem does not authorise an action. Authorisation comes explicitly from the user, not from the model's inference that action is warranted.
The specific failure mode it prevents: a user asks "diagnose why the performance is slow." The model identifies a database query as the likely cause, then also rewrites the query because the fix was obvious. The user wanted a diagnosis, not a change. scope-guard makes this distinction enforced rather than requested.
Unrequested state changes of any kind are blocked. This includes: writes inferred from reads, fixes inferred from diagnostics, configurations inferred from problems, and migrations inferred from schema mismatches.
Copy-paste prompts
"Load scope-guard skill.
Diagnose: [DESCRIBE WHAT TO DIAGNOSE]
Return only a diagnosis. Do not make any changes, writes, or state modifications.
If you find something that should be fixed, document it as a recommendation.
Wait for explicit authorisation before acting on any recommendation."
"Load scope-guard skill.
Audit this codebase for [ISSUE TYPE].
Deliverable: a report listing findings with severity and recommended actions.
Deliverable is not: any changes to files, configs, or state.
Do not fix anything you find. Document it."
Skill 7: subagent-orchestration
Fable 5 is significantly better at multi-agent work than previous models. subagent-orchestration provides the patterns for exploiting this: parallel delegation, long-lived workers, and fresh-context verifier subagents that out-perform self-critique.
What it does
Three patterns the skill defines:
- Parallel delegation
When a task has independent subtasks, spawn subagents for each. They run in parallel rather than sequentially. The orchestrator collects results and synthesises. For GTM workflows: research agent + writing agent + review agent running simultaneously.
- Long-lived workers
For tasks that persist across a session (monitoring, continuous processing, background work), the skill defines how to structure a long-lived subagent that maintains context across turns without being restarted.
- Fresh-context verifier subagents
Self-critique fails because the model is defending its own work with the same context that produced the error. A verifier subagent is spawned with only the output and the requirements, no access to the reasoning that produced the output. Fresh-context verification is more reliable than self-critique for correctness-critical tasks.
Copy-paste prompts
"Load subagent-orchestration skill.
Task: [DESCRIBE MULTI-STEP TASK WITH INDEPENDENT COMPONENTS]
Identify which subtasks are independent and can run in parallel.
Delegate each to a subagent. Run in parallel.
Collect results and synthesise into a final output."
For GTM workflows:
"Load subagent-orchestration skill.
Run a research crew for [COMPANY NAME]:
Subagent 1: Research the company and produce a brief (signals, decision makers, tech stack, news)
Subagent 2: Research recent LinkedIn activity from the target persona
Subagent 3: Check competitor reviews on G2 for common complaints
Run all 3 in parallel. Return results.
Then: synthesise into a one-page account brief."
Fresh-context verification:
"Load subagent-orchestration skill.
I have produced this output: [PASTE OUTPUT]
The requirements were: [PASTE REQUIREMENTS]
Spawn a fresh-context verifier subagent with only the output and requirements.
Do not provide the verifier with the reasoning that produced the output.
Verifier task: does the output satisfy the requirements? What is missing or wrong?"
Skill 8: markdown-memory
Fable 5 exploits file-based memory unusually well compared to previous models. markdown-memory provides the structure and maintenance discipline needed to keep a lesson memory file useful over time rather than letting it drift into noise.
What it does
File-based memory in Claude Code works by writing lessons, decisions, and context to a markdown file that gets loaded into the session. Fable 5 reads and applies this context more reliably than previous models.
The skill defines two things:
- The write discipline: what gets written to memory (lessons that changed behaviour in a session, decisions that should not be re-derived, context that would take more than one turn to reconstruct) and what does not (observations, summaries, anything that does not change future action).
- The maintenance discipline: when to review and prune the memory file. Memory files that grow without pruning become noise that degrades rather than improves performance. The skill defines a review trigger and a pruning rule.
Copy-paste prompts
"Load markdown-memory skill.
At the end of this session, write any lessons to MEMORY.md that meet this test:
'Would this lesson change how I approach a similar task in a future session?'
Do not write:
- Summaries of what we did
- Observations that do not change future action
- Context that can be reconstructed from the codebase
Write:
- Decisions that should not be re-derived
- Patterns that failed and should not be tried again
- Context that took multiple turns to establish"
"Load markdown-memory skill.
Review MEMORY.md. Apply the pruning rule:
Remove any entry that no longer changes future action.
Remove any entry that has been superseded by a newer entry.
Remove any entry that describes a situation that no longer exists in the codebase.
Return the pruned MEMORY.md."
Skill 9: autonomous-continuation
Fixes unattended runs that stall. Without this skill, Fable 5 on a long unattended task can pause mid-run to narrate what it is about to do ("I will now run the test suite") or ask permission for actions it was already authorised to take. autonomous-continuation keeps it moving.
What it does
Two failure modes the skill addresses:
- Narration stalls
The model announces an action instead of taking it. "I will now run the migration script." Then waits. This is a pattern from older models where announcing actions was a checkpointing behaviour. Fable 5 has better checkpointing but the pattern persists. autonomous-continuation defines a rule: announced actions are executed, not reported as pending.
- Mid-run permission questions
The model asks for confirmation on an action it was already authorised to take at the start of the task. "Are you sure you want me to update the database?" when the task was explicitly "update the database." The skill defines the authorisation boundary clearly: actions within the stated task scope do not require re-confirmation unless they exceed the stated scope.
Context-budget composure pattern (from the repo): as a long unattended run approaches the context limit, the model should complete the current subtask cleanly rather than starting new work that will be cut off. The skill defines a context-budget checkpoint that triggers graceful wind-down rather than abrupt stops.
Copy-paste prompts
"Load autonomous-continuation skill.
Task: [DESCRIBE MULTI-STEP TASK]
Run autonomously until complete or until you hit a genuine blocker.
Do not pause to announce steps before taking them.
Do not ask for confirmation on actions within the stated scope.
If you reach a blocker that requires human input, report it and wait.
If you approach the context limit, complete the current subtask and produce a handoff summary."
"Load autonomous-continuation skill.
Run this overnight: [DESCRIBE LONG-RUNNING TASK]
Context-budget rule: when you estimate you are within 20% of context capacity,
do not start a new major subtask. Complete the current one and write a handoff summary to HANDOFF.md
that lets a fresh session pick up from exactly this point."
Skill 10: regrounding-summary
Final reports must be readable by someone who saw none of the work. Without this skill, Fable 5 summaries can use implicit arrow chains (A → B → C), invented abbreviations from within the session, and forward-references to decisions that were made 30 turns back. regrounding-summary prevents all of these.
What it does
The skill defines a readability test for any final report: can someone who has not participated in the session read this and understand what happened, what was decided, and what the next steps are?
Specific patterns it blocks:
- Arrow chains: A → B → C notation that requires knowing what A, B, and C referred to
- Invented abbreviations: short forms that were established during the session but mean nothing outside it
- Session-internal references: "as discussed in the planning step" when the reader has no planning step
- Implicit context: conclusions stated without the premises that support them
What a regrounding summary contains: a clear statement of what was asked, what was done, what was found, what decisions were made and why, and what the next steps are. No assumptions about what the reader knows from the session.
Copy-paste prompts
"Load regrounding-summary skill.
At the end of this session, produce a summary that meets this test:
Someone who was not in this session should be able to read it and fully understand:
- What was asked
- What was done
- What was found or produced
- What decisions were made and the reasoning behind each
- What the next steps are
Do not use:
- Abbreviations established in this session
- Arrow chains
- References to earlier turns without quoting the relevant content
- Conclusions without premises"
"Load regrounding-summary skill.
Review this summary I produced: [PASTE SUMMARY]
Apply the readability test: can someone who was not in the session read this?
For each passage that fails the test, rewrite it to be self-contained.
Flag any invented abbreviations or session-internal references."
Quick Reference: Install Commands and All Prompts
Every install command and copy-paste prompt in one place.
Install commands
# Via plugin marketplace (recommended, gets updates)
/plugin marketplace add kpab/claude-fable-5-skills
/plugin install fable5-skills@claude-fable-5-skills
# Manual full install
git clone https://github.com/kpab/claude-fable-5-skills
cp -r claude-fable-5-skills/skills/* ~/.claude/skills/
# Cherry-pick individual skills
cp -r claude-fable-5-skills/skills/no-gold-plating ~/.claude/skills/
cp -r claude-fable-5-skills/skills/act-when-ready ~/.claude/skills/
cp -r claude-fable-5-skills/skills/effort-calibrator ~/.claude/skills/
# Per-project installation (scoped to one repo)
mkdir -p .claude/skills
cp -r claude-fable-5-skills/skills/scope-guard .claude/skills/
The recommended install order
# Step 1: Install skill-refactorer first
cp -r claude-fable-5-skills/skills/skill-refactorer ~/.claude/skills/
# Step 2: Run it on your existing CLAUDE.md and skill files
"Run skill-refactorer on CLAUDE.md and every file in ~/.claude/skills/.
Audit for capability-compensation scaffolding and procedures that should be intent + boundary.
Produce a refactored version of each file and a diff log."
# Step 3: Install the rest
cp -r claude-fable-5-skills/skills/* ~/.claude/skills/
# Step 4: Set effort to medium as your default
# In .claude/settings.json or equivalent:
{
"model": "claude-fable-5",
"effort": "medium"
}
All 10 copy-paste prompts at a glance
# skill-refactorer (meta-skill, run first)
"Run skill-refactorer on [FILE PATH or PASTE CONTENT].
Remove capability compensation. Convert procedures to intent + boundary."
# act-when-ready
"Load act-when-ready. Task: [DESCRIBE TASK].
Start executing once you have enough information. No pre-flight planning for clear tasks."
# effort-calibrator
"Load effort-calibrator. Task: [DESCRIBE TASK].
What effort level is appropriate? Execute at that level."
# no-gold-plating
"Load no-gold-plating. Fix: [DESCRIBE BUG/CHANGE].
Diff touches only lines required by the ask. Flag anything additional before making it."
# grounded-progress
"Load grounded-progress. Task: [DESCRIBE TASK].
Every status claim cites a specific tool result. No narrated completion without evidence."
# scope-guard
"Load scope-guard. Diagnose: [DESCRIBE WHAT TO DIAGNOSE].
Return diagnosis only. No changes. Document recommendations and wait for authorisation."
# subagent-orchestration
"Load subagent-orchestration. Task: [DESCRIBE MULTI-COMPONENT TASK].
Identify parallel subtasks, delegate, run simultaneously, synthesise."
# markdown-memory
"Load markdown-memory. End of session:
Write lessons to MEMORY.md that would change how I approach similar tasks. Prune stale entries."
# autonomous-continuation
"Load autonomous-continuation. Task: [DESCRIBE LONG TASK].
Run until complete. No narration stalls. No re-confirmation within scope.
At context limit: complete current subtask, write handoff to HANDOFF.md."
# regrounding-summary
"Load regrounding-summary. End of session:
Produce a summary readable by someone who saw none of this work.
No session abbreviations, no arrow chains, no implicit premises."
Compatibility
Works with: Claude Code, Claude Cowork, Cursor, GitHub Copilot, Gemini CLI, and any harness that reads SKILL.md files in agentskills.io-style format (YAML frontmatter + Markdown body).
Fable 5 shipped 2026-06-09. These skills track a moving target as the community learns the model. Issues and PRs with reproducible before/after examples are welcome at github.com/kpab/claude-fable-5-skills.
This is an unofficial community project, not affiliated with or endorsed by Anthropic. Verify current API parameters against the official docs before production use.
