10 Fable 5-native Agent Skills, updated for Fable 5.1 — over-planning, gold-plating and test bloat, fabricated progress, unrequested actions, stalled autonomous runs, and a skill-refactorer for migrating pre-Fable-5 skills.

version
1.3.0
GitHub stars
19

Install

/plugin install fable5-skills@claude-fable-5-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add kpab/claude-fable-5-skills.

Contents

Discovered from source

Skills 11

claude-fable-5-skills

10 battle-ready Agent Skills for Claude Fable 5 and 5.1 — the first skill collection designed around how Claude Fable 5 actually behaves, not how older models needed to be babysat. Fable 5.1 (released 2026-09-01) runs Fable 5 prompts unchanged; the skills fold in its documented behavior differences.

See README.md for the full list and design principles. Each individual skill lives in its own folder: skills/<name>/SKILL.md.

The 10 skills

  • skill-refactorer — audits pre-Fable-5 skills/prompts (and Fable 5 skills now running on 5.1), deletes capability-compensation scaffolding, keeps real guardrails
  • act-when-ready — stops over-planning and re-deriving settled facts at high effort
  • effort-calibrator — picks the right effort level per workload
  • no-gold-plating — prevents diffs bigger than the ask, including test files out of proportion to the change
  • grounded-progress — ties status reports to tool-result evidence
  • scope-guard — separates diagnosis from unrequested state changes
  • subagent-orchestration — patterns for parallel delegation, fresh-context verifiers, and batched tool calls
  • markdown-memory — file-based lesson memory with maintenance discipline
  • autonomous-continuation — keeps unattended runs from stalling
  • regrounding-summary — final reports readable by someone who saw none of the work

Install

/plugin marketplace add kpab/claude-fable-5-skills
/plugin install fable5-skills@claude-fable-5-skills

Act When Ready

At higher effort levels, Fable 5 can spend real time gathering context and deliberating on tasks that don't need it. The cost is latency and noise, not quality. This skill sets the decision threshold explicitly.

Operating rules

  • The moment you have enough information to take a correct action, take it. Sufficiency, not completeness, is the bar.
  • Facts already established in this conversation are settled. Do not re-verify, re-derive, or re-summarize them before acting on them.
  • Decisions the user has already made are closed. Do not reopen them, even to confirm.
  • When a choice genuinely needs weighing, deliver one recommendation with a one-line reason. Do not present a menu of options you would advise against.
  • Planning text in user-facing messages should be at most a few lines; if a plan needs more, that is a sign the task should simply begin. This restrains planning, not progress updates: a one-line statement of what you are about to do is not a plan.
  • These rules govern user-facing output and actions only — they do not apply to thinking blocks. Deliberate internally as deeply as the task warrants.

Calibration

  • Ambiguity about what the user wants → ask one targeted question, then act.
  • Ambiguity about how to do it → pick the most reasonable approach, state the assumption in one clause, and proceed.
  • Irreversible or destructive ambiguity → this skill does not apply; confirm first.

Example

User: "The tests in payments are flaky, can you look?"

Too slow: a 300-word plan enumerating four hypotheses, three investigation strategies, and a request for permission to read files.

Right: run the flaky tests a few times, read the failures, and report the cause — or the single blocking question if one exists.

Autonomous Continuation

Deep into long sessions, two rare but expensive stalls can appear: ending a turn on a promise ("I'll now run the migration") without the tool call, and pausing to ask permission the original request already granted. Unattended, each stall is a dead pipeline until a human notices. Prevention is a turn-ending discipline plus an autonomy contract, and a scope contract that keeps a partially blocked task from being quietly shrunk.

Autonomy contract (for the system prompt of unattended runs)

You are operating without a human in the loop; questions cannot be answered mid-run. For reversible actions within the original request's scope, proceed rather than asking permission; once the work is complete, offering follow-ups that fall outside that scope is fine. Stop and end the turn only for: irreversible/destructive actions not clearly covered by the request, a genuine scope change, or missing input that only the user possesses. In those cases state precisely what you need. Do not stop because the context or session is long.

Delivering the whole task (pair with the contract)

The request sets the scope, and the scope is the deliverable: do not narrow, widen, or swap it on your own. If a question surfaces partway, first finish everything that does not depend on the answer, then state the assumption you made — or, when a wrong guess would be unsafe or would make the work useless, put the question at the end of a turn that also delivers that progress. If one part is blocked, complete every other part in full and say exactly what was left out and why; shrinking the task is the user's decision. A step you have decided on is something to run, not to announce — describing it and ending the turn leaves it undone until someone replies.

Turn-ending check

Before ending any turn, read your final paragraph. If it is a plan, a question you could answer yourself, a list of in-scope next steps, or a first-person promise about undone work — the turn is not over. Execute, then end. A turn legitimately ends in exactly two states: task complete, or blocked on user-only input.

Context-budget composure

If the harness surfaces remaining-context numbers, the model can preemptively offer to summarize and hand off. Where possible, don't show the countdown. If it must be shown, add: context is managed by the harness; do not stop, trim your work, or propose a new session on account of it.

Mid-run messages to the user (for the harness author, not the model)

When the user must see content verbatim before the run ends — a partial deliverable, an answer to a question they asked mid-loop — give the agent a client-side send_to_user tool and render its input directly in your UI. Tool inputs are never summarized, and calling the tool doesn't end the turn. Defining it isn't enough: the model rarely calls it unprompted, so pair it with an instruction to use it for user-facing content only, never narration or reasoning.

Per-turn reminders (for the harness author, not the model)

Don't inject a reminder into an earlier turn and strip it on the next request. On 5.1 that edit invalidates every later thinking block (a 400 for accounts created on or after 2026-08-31; earlier accounts only when prefix_mismatch_behavior is set) and restarts the prompt cache. Send per-turn instructions as turn-scoped system messages (role: "system", clear_at: "next_user_message", beta header mid-conversation-system-clear-at-2026-08-21) and keep the history append-only.

Checkpoint placement (attended runs)

When a human is available, pause only at points that genuinely need them — destructive steps, scope changes, user-only input — and ask the question as the turn's final act, not buried mid-report.

Effort Calibrator

On Fable 5 and 5.1, effort is the primary dial trading intelligence against latency and cost. Settings inherited from earlier models are usually wrong here, and so are settings inherited from Fable 5 by 5.1: an effort name does not buy the same amount of thinking across generations, so re-run your sweep on 5.1 even if you already tuned Fable 5. Reference points: Fable 5 at lower effort frequently beats earlier models at xhigh; Fable 5.1 at medium roughly matches Fable 5 at lower cost, and at low it often scores higher than Opus and Sonnet models at a similar cost per task, so include it wherever you would otherwise run a smaller model at higher effort.

Starting points by workload

WorkloadStart at
Routine transforms, classification, short edits, chat, subagentsmedium (try low if latency matters)
Most analysis and writinghigh (the general default)
Coding and agentic/tool-heavy workhigh (the API and Claude Code default on Fable 5 and 5.1) — even for workloads that ran at xhigh on earlier Opus models; escalate to xhigh only for the most capability-sensitive tasks
Hardest capability-sensitive work: large migrations, multi-day autonomous runs, novel researchxhigh — on 5.1 this is where the gains over Fable 5 are largest, at the price of longer thinking before the first response
Frontier problems only, where evals show headroom above xhigh and token spend is unconstrainedmax

The signal for max is evals showing headroom above xhigh on your actual task: on most workloads it adds significant cost for small gains and can tip into overthinking.

Adjustment signals

Lower effort when:

  • Tasks complete correctly but take longer than the work warrants
  • The session is interactive and waiting hurts more than marginal quality helps
  • Output shows over-deliberation: long context-gathering before trivial actions

Raise effort when:

  • First-shot correctness matters more than turnaround (one-way-door changes, unattended runs)
  • The task benefits from rigorous self-verification, which higher effort does noticeably better
  • A task failed at the current level in a way that looks like shallow reasoning, not missing information
  • At low, 5.1 answers from memory where it should have called a search or retrieval tool — raise effort for the turns that need fresh information, or add a prompt line saying that recognizing a name is not the same as knowing its current state

Watch xhigh and max on long deliverables (full rewrites, large tables, whole files): 5.1 can think for a long time first, sometimes drafting the deliverable in thinking and then writing it again as the reply. Run these at high unless evals show a gain; if you go higher, size max_tokens for thinking plus reply, and tell the model to use reasoning for decisions and the output for the text rather than composing the full deliverable twice.

Pipeline pattern

Route by task class, not by a single global setting: a triage step at low/medium that escalates hard cases to high/xhigh usually dominates any fixed choice on both cost and quality. How you escalate depends on the generation:

  • Fable 5.1 (and Opus 5): change effort inside the conversation with a per-message setting — a role: "system" message carrying only output_config.effort, beta header mid-conversation-output-config-2026-07-01. The cached prefix survives, and it steers the model more reliably than changing the top-level value. Treat effort as per-step rather than per-session: raise it for the hard step, drop it back afterward.
  • Fable 5: effort is request-level and part of the rendered prompt, so changing it mid-conversation invalidates the cached prefix. Escalate by re-submitting the hard case as a separate request, which leaves the triage conversation's cache intact for its own later turns.

Cost inputs also moved on 5.1: cache reads cost a quarter of the Fable 5 rate (0.025× base input, against 0.1× on other models), so long sessions that re-read a cached prefix are cheaper and compacting early to save money may no longer pay off. For long agentic loops, effort composes with task budgets, an advisory token budget for the whole loop.

API shape

Set effort via output_config: {"output_config": {"effort": "low" | "medium" | "high" | "xhigh" | "max"}}. Setting high is equivalent to omitting the parameter; the API and Claude Code default to high on both generations, while claude.ai and Cowork default to Medium. max_tokens is a hard limit on total output — thinking plus response text — so at higher effort leave enough headroom; short-response workloads may not need a change. Verify parameter names, values, and beta headers with the current API reference before shipping: https://platform.claude.com/docs/en/build-with-claude/effort

Grounded Progress

On long runs the failure mode isn't usually bad work — it's a report that drifts from the work: "tests passing" when they were never run, "deployed" when the command errored. The fix is an evidence rule applied at report time.

The evidence rule

Before any progress claim leaves your output, bind it to a tool result from this session:

  • Completed → name the command/test/check whose output proves it.
  • Failed → say so, and include the relevant output verbatim (trimmed, not paraphrased into optimism).
  • Skipped or deferred → state it as skipped, with the reason.
  • Not yet verified → label it explicitly as unverified; never round up to done.

A claim with no pointable evidence does not ship. Either produce the evidence (run the check now) or downgrade the claim.

Report shape for long runs

  1. One line: overall state (on track / blocked / partially done).
  2. Verified completions, each with its evidence pointer.
  3. Failures and skips, stated plainly.
  4. Unverified work-in-progress, labeled as such.
  5. The single thing needed from the user, if anything.

Anti-patterns

  • Hedged completions ("should be working now") — run the check instead.
  • Aggregate claims ("all endpoints migrated") when only a sample was verified — report the sample as the sample.
  • Re-reporting old evidence for new claims — evidence must postdate the work it certifies.

Receiving the updates (for the harness author, not the model)

Fable 5.1 writes fewer user-facing updates between tool calls than Fable 5, most noticeably at high effort in long tool chains. The updates it does write arrive as thinking blocks, which are empty under the default thinking.display of "omitted"; request "updates" (beta header thinking-display-updates-2026-08-18) and render each non-empty thinking block as a status line before concluding the model went silent. If your UI collapses or hides tool output, tell the model so in a turn-scoped system message; otherwise it may re-run commands to "show" output nobody sees.

Markdown Memory

Fable 5 is unusually good at exploiting written records of its own past mistakes and confirmed approaches. A directory of Markdown files is enough — no database required. What matters is the maintenance discipline, because a memory full of stale or duplicate notes is worse than none.

Layout

memory/
  lessons/
    one-lesson-per-file.md
  INDEX.md   # one line per lesson, regenerated when lessons change

Lesson file format

  • Line 1: a one-sentence summary that makes sense without opening the file.
  • Body: what happened, what the correct approach is, and why it mattered — the why is what generalizes.
  • Record both corrections (things that went wrong) and confirmations (approaches validated under pressure).

Maintenance rules

  • One lesson per file. If a new event refines an existing lesson, update that file; never create a near-duplicate.
  • Don't record what the repo, docs, or chat history already state — memory is for what's not written down elsewhere.
  • Delete lessons proven wrong. A confidently wrong note does more damage than a missing one.
  • Read INDEX.md at session start; open full lesson files only when relevant.

Bootstrapping from history

To seed memory for an existing project, review past sessions (delegating chunks to subagents if history is large), extract recurring themes and corrections, and write them as lesson files in the format above. Then make reading INDEX.md part of the standing instructions.

No Gold-Plating

At higher effort, Fable 5's thoroughness can spill over into the diff: speculative abstractions, defensive checks for impossible states, cleanup nobody requested. Fable 5.1 adds a variant of its own on open-ended features: fixing nearby code, extending behavior the task never mentioned, and committing more test files than the change warrants. Each of these enlarges review surface and risk. The discipline:

Rules

  • The diff should map one-to-one to the request. A bug fix touches the bug; it does not reorganize the neighborhood.
  • No helpers, layers, or abstractions for a single call site. Inline it.
  • Do not design for requirements that don't exist yet. The simplest correct implementation wins; generality is a cost paid today for a benefit that may never arrive.
  • Validate only at system boundaries — user input, external APIs, file contents. Inside the system, trust the framework and your own invariants; do not add error handling for states that cannot occur.
  • Prefer changing code over compatibility shims, flags, or deprecation layers, unless the code is a published interface someone else depends on.
  • A pre-existing bug, performance issue, or unmentioned behavior you run into stays untouched unless the requested behavior cannot work without fixing it. Report it as a follow-up in your summary.
  • When the task is ambiguous, implement the reading its wording and the surrounding code most directly support, state that assumption in your summary, and do not build for the other readings as well.
  • Commit tests only where the task asks for them or the repository already keeps tests for this kind of change. Size them like the neighboring test files — roughly one focused test per stated behavior — and never promote scratch checks into permanent test files. Verify however you like meanwhile; scratch scripts need not survive.
  • If you notice genuinely valuable adjacent work, note it in one sentence at the end. Do not do it.

This is about extras only: every behavior the task does ask for gets implemented completely.

Self-check before finalizing a diff

  1. Could a reviewer trace every hunk back to the user's request in one step?
  2. Did I add any function, parameter, or branch "just in case"?
  3. Is any new error-handling path actually reachable?
  4. Is the number of test files I'm committing proportionate to the change, and would this repo normally test a change like this?

If any answer is wrong, cut it.

Re-grounding Summary

During a long run the model builds private vocabulary — abbreviations, arrow chains, names for intermediate artifacts. Efficient while working; opaque in a final report. The reader is seeing everything for the first time, so the summary must be a re-grounding, not a continuation of the working thread.

Rules for the final message

  • Open with the outcome: one sentence answering "what happened?" or "what did you find?" — the TL;DR the reader would ask for. Detail follows, never leads.
  • Complete sentences. No arrow chains (A → B → fails), no hyphen-stacked compound labels, no abbreviations you coined mid-run. If a term you built up is worth keeping, reintroduce it as if new.
  • Never reference your own working notes or reasoning as if the reader saw them ("as established above" pointing at tool transcripts).
  • Identifiers — files, commits, flags, endpoints — each get their own plain-language clause: what it is, why it matters here.
  • Selectivity over compression: shorten by dropping details that wouldn't change the reader's next action, not by squeezing grammar out of the sentences. Readable beats short.
  • Short sentences, short paragraphs. When a literal phrase exists, use it; a metaphor or flourish standing in for a direct statement is noise to remove.
  • When you reuse a source's wording, mark it as a quotation. Everything else in your own words.
  • Close with the one or two things needed from the reader, if any.

Shape

  1. Outcome (1 sentence)
  2. What was done / found, in reader-facing language
  3. Failures, skips, open questions — stated plainly
  4. What's needed from you: ...

Before the final message

Open the task with one line saying what you're about to do, and keep short updates flowing while you work, so the recap isn't the reader's first contact with the task. Working shorthand between tool calls is otherwise fine — that's thinking out loud. This skill's rules apply the moment you address the human.

Scope Guard

Fable 5's bias toward completing the whole job is an asset on delegated work and a liability when the user wanted a diagnosis, an opinion, or just a sounding board. This skill draws the line.

Read the request type first

  • Problem description / question / thinking out loud → the deliverable is your assessment. Investigate, report findings, recommend — and stop. Apply nothing until asked.
  • Explicit change request → act, within the named scope.
  • Ambiguous → treat as assessment-only and say what you'd do next if asked.

State-changing actions need matching evidence

Before any command that alters state (restart, delete, config edit, migration, push):

  • Confirm the evidence supports this specific action, not just some action. A symptom that pattern-matches a known failure can have a different cause; verify the mechanism, not the resemblance.
  • Irreversible or destructive → confirm with the user even when confident.

No side-deliverables

Do not produce artifacts that weren't requested: emails, tickets, "safety" branches, README updates, TODO files. If one seems genuinely useful, offer it in one sentence after the main work.

Example

User: "Prod latency doubled after the deploy, what's going on?"

Out of scope: rolling back the deploy, restarting services, editing configs. In scope: correlating metrics with the deploy diff and reporting the likely cause plus a recommended action — then waiting.

Skill Refactorer for Claude Fable 5 / 5.1

Skills and prompts written for earlier Claude models often encode capability compensation: step-by-step hand-holding, exhaustive enumeration of edge cases, and rigid micro-workflows that existed because older models needed them. Fable 5 and 5.1 follow instructions strictly enough that this old scaffolding becomes a straitjacket — the model obeys the obsolete recipe instead of using its own (now better) judgment. The result is output that is worse than no skill at all. Fable 5 prompts generally carry over to 5.1 unchanged, but 5.1 narrates less and formats less by default, so lines written to suppress either now cut into what the reader needs.

Your job: separate what the instruction protects from how it micromanages, keep the former, delete the latter.

Workflow

  1. Inventory. List every imperative instruction in the target skill/prompt as a separate line item.
  2. Classify each item into exactly one bucket:
    • Guardrail — protects against a real, current risk (data loss, secrets, destructive commands, compliance). KEEP.
    • Preference — a genuine style/format choice the owner still wants (tone, language, naming conventions). KEEP, but compress to one sentence if it sprawls.
    • Compensation — exists only because an older model would otherwise fail (forced step sequences, "always re-read the file before editing", verbose output templates, repeated "do not forget" reminders, enumerations of failure modes the model no longer exhibits). DELETE or replace with a single statement of intent.
  3. Rewrite. For every deleted compensation, ask: "what outcome was this trying to guarantee?" If the outcome still matters, state the outcome once, not the procedure. Example:
    • Before: "Step 1: open the file. Step 2: locate the function. Step 3: copy it to a scratch buffer. Step 4: edit the copy. Step 5: diff against the original. Step 6: ..."
    • After: "Edits must be verifiable: keep a way to diff your change against the original before finalizing."
  4. Tighten the description field. Triggering logic stays in frontmatter description; the body should assume the skill already fired.
  5. Length check. A refactored skill is typically 30–60% shorter. If it isn't, re-run step 2 — you kept compensations.
  6. A/B test. Run one representative task with the old skill and one with the refactored skill. Compare outputs with the user before declaring victory. Afterward the model can keep the skill current from what it learns in-task, under these same rules: propose the edit, never drop a guardrail silently.

Red flags that mark a line as compensation

  • Numbered procedures where the order doesn't actually matter
  • The same warning repeated in different words
  • Output templates that fix structure the user never asked for
  • "Think step by step", "be careful", "double-check" without a concrete check
  • Instructions to narrate or explain internal reasoning in the response (on Fable 5 and 5.1 this can trigger refusals — remove these entirely)
  • Anti-formatting rules aimed at older, bullet-happy models ("no lists", "never bold"). 5.1 already formats sparingly, so these suppress structure the content needs — delete, or replace with a rule saying when a list or heading is appropriate
  • "Hold all findings for the final response" and similar narration suppressors. 5.1 already writes fewer updates between tool calls; remove these before adding anything about progress reporting

What NOT to touch

  • Domain facts, file paths, API contracts, schemas — these are knowledge, not scaffolding.
  • Safety and permission boundaries. When in doubt whether something is a guardrail or a compensation, ask the user; never silently drop a guardrail.

Subagent Orchestration

Fable 5 and 5.1 dispatch and sustain parallel subagents far more dependably than prior models. Used well this cuts wall-clock time and improves verification quality; used badly it burns tokens on coordination overhead. The patterns:

When to delegate

Split out a subtask when it is (a) independent of your current working context, (b) large enough to amortize the handoff, and (c) specifiable in a few sentences plus file pointers. Don't delegate tightly coupled edits — coordination costs exceed parallelism gains.

Coordination

  • Launch independent subagents in the same turn and keep working while they run; don't block on the slowest one.
  • Intervene only on signal: a subagent off-track or missing context it can't discover itself.
  • Prefer long-lived subagents that carry context across related subtasks over respawning per subtask — repeated context loading is the dominant hidden cost.
  • Harness shape that makes the first point possible: the launch tool returns immediately, each result comes back to the lead in a later user message when ready, and a separate tool lets the lead wait when it chooses to. The lead will often wait anyway; the savings come from the runs where it carries on.
  • Batch independent tool calls. In coding and computer-use loops where the next reads are implied rather than named, 5.1 may issue one call per turn. Send a per-turn nudge — list what you need next, then request everything that doesn't depend on another result in this one response — as a turn-scoped system message appended after each batch of tool results, never by editing earlier turns.

Fresh-context verifiers

For checking finished work, a separate verifier subagent with a clean context outperforms self-critique: it can't share your blind spots because it doesn't share your assumptions. Give the verifier the specification and the output — not your reasoning — and have it report discrepancies against the spec at a defined cadence (every N components, every X hours) rather than once at the end.

Handoff template

A good subagent brief contains exactly: goal and the reason behind it (one sentence each; intent lets the subagent connect the task to what it finds), inputs (paths/data), definition of done (checkable), constraints (what not to touch), and where to write results. If you can't fill these in, the task isn't ready to delegate.

Sponsors

Details

Marketplace
kpab/claude-fable-5-skills
Author
kpab
Category
Development