Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

fable

/fable

Zleca modelowi Fable 5 zaplanowanie zadania i przegląd zmian po wykonaniu, a sam kod pisze mniejszy model.

Repozytorium
fable-bench ↗
Licencja
MIT
Ostatnia zmiana repozytorium
20.09.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zleca modelowi Fable 5 zaplanowanie zadania i przegląd zmian po wykonaniu, a sam kod pisze mniejszy model.

Wyzwalacze z opisu

get a Fable planconsult Fablecritique my plan
Oryginalny opis (EN)

Have Claude Fable 5 plan the current task, then run an automatic warm diff-review after you execute. You (the below-Fable driver — Sonnet or Opus) gather the evidence and execute; Fable is the context-blind PLANNER — one plan engagement at the start (it writes the plan, unanchored by any draft of yours), one warm review at the end. Trigger on "/fable", "get a Fable plan", "consult Fable", or when the user wants Fable-planned execution of a nontrivial change. An explicit "critique my plan" request switches to the opt-in critique mode.

Jak działa

  1. The flow
  2. Critique mode (opt-in only — user explicitly asked for a critique of YOUR plan)
  3. Building the brief — this is where a consult lives or dies
  4. Batch mode (≤3 small related items)
  5. Review-only mode (mechanical, pre-approved items)
  6. Reading Fable's coded output
  7. Bindingness & tie-breaks
  8. Never consult Fable about
Sekcje z nagłówków SKILL.md, w oryginale · 256 linii, 2 925 słów
Podgląd SKILL.md
---
name: fable
description: Have Claude Fable 5 plan the current task, then run an automatic warm diff-review after you execute. You (the below-Fable driver — Sonnet or Opus) gather the evidence and execute; Fable is the context-blind PLANNER — one plan engagement at the start (it writes the plan, unanchored by any draft of yours), one warm review at the end. Trigger on "/fable", "get a Fable plan", "consult Fable", or when the user wants Fable-planned execution of a nontrivial change. An explicit "critique my plan" request switches to the opt-in critique mode.
---

# /fable — Fable plans, you execute

You are the driver (below-Fable — Sonnet or Opus): you hold full session context, gather the
evidence, execute, and make every micro-judgment yourself. Fable 5 is the PLANNER — stronger
judgment, ZERO session context; it reads only what your brief points to, and it writes the
plan unanchored by any draft of yours. It is never in the loop. Across one `/fable` you touch
Fable twice — **one plan engagement** at the start, **one warm review** at
the end (a resume of the same agent) — plus at most one exception-triggered mid-consult
(S5). Never a scheduled third touch. **MODEL GATE:** if this session's
driving model is itself Fable-tier, never spawn `fable-planner` — you ARE the
planner, and a spawn pays twice for the same judgment. `/fable` then means:
plan it yourself (S1's evidence discipline still applies), execute per S5/S5-alt, review the
diff YOURSELF (S5-alt's `reviewer` spawns don't apply — a Fable lead reads
worker diffs first-hand), plus `smoke-tester` when runtime behavior changed.
All Fable-touch budgets read as zero.

**Hard dependency:** the warm review resumes the plan agent via `SendMessage`. If your harness
cannot resume a subagent, `/fable` cannot review — there is no cold fallback. The preflight
(S0.5) checks this before you spend the plan consult.

**Native advisor first:** when `advisorModel: fable` is set (as on this install), a below-Fable driver
already has Fable judgment on tap mid-task — the advisor reads the FULL conversation
server-side, no brief needed. For an ad-hoc second opinion, prefer asking for an advisor
consult over invoking this skill. `/fable` remains the right tool when you want the full
discipline: a Fable-authored plan built from grounded evidence, plus the owed warm
diff-review at the end.

## The flow

**S0 — Ground the brief.** Fable plans only as well as your brief. For anything beyond a
local, self-evident change, delegate mapping to `explorer` workers (scale it: skip for a
one-file change, fan out several for a subsystem consult) and fold their CONCLUSIONS — not
raw dumps — into the brief. When the mapping is destined for a consult brief, instruct
`explorer` to return NEUTRAL fact-maps (interfaces, call paths, invariants, line refs), not
recommendations — driver-flavored conclusions re-anchor the exact frame the blind plan
exists to avoid. Capture the project's **test / verify command** and RUN it once
(inline or via `verifier`): the brief must state the baseline WITH its provenance line
(`BASELINE: green — MEASURED: <cmd> · <tree>`, or the red facts with theirs) so Fable
never plans against a false premise, and S7 needs the command. Resolve
every lookup yourself now (Lookup fence, below) so the brief carries established facts, not
questions.

**S0.5 — Preflight dependencies.** Confirm warm subagent-resume (`SendMessage` to a spawned
agent) is available; if NOT, tell the user `/fable` can't run without it and STOP — fail
before paying for the plan consult. `TaskCreate` is degradable: if absent, carry the S4
checkpoint in your own running notes and continue.

**S1 — Mode check.** Default is **plan mode**: the brief carries evidence and NO plan of
yours — Fable writes the plan. Do NOT draft one first, even privately-then-discarded: your
questions and framing leak its shape, and an anchored Fable plan is the failure this skill
exists to avoid. **Critique mode** is opt-in only — the user explicitly asked you to draft
and have Fable critique it (see Critique mode below).

**S2 — Build the plan brief** to the spec below, gated by the Lookup fence.

**S3 — Spawn `fable-planner`.** One plan engagement. It returns a numbered PLAN (S1, S2…)
with RISKS / CHECKPOINTS / ASSUMPTIONS in the coded format below; that plan is what you
execute and what the warm review audits against. Apply per Bindingness.

**S4 — Register the owed warm review as a self-contained task item.** `TaskCreate` a
checkpoint that survives the execution turns. It MUST embed: the **`fable-planner` agent
id/handle** (from S3's spawn result), a pointer to the **warm review brief spec** (below),
and the precondition — **fire only after execution AND verification evidence are complete**.

**S5 — Execute inline.** Keep a deviations log: one line per departure from the accepted
plan, with reason. Check Fable's CHECKPOINTS as you pass them. **Exception mid-consult:** if
a CHECKPOINT fails or a listed ASSUMPTION proves false mid-task, you may resume the agent
once — send only the failed item + the observed facts; it rules on holding vs replanning the
affected steps. This is the only permitted mid-task touch; never resume for reassurance or a
partial-diff review (half-built code reads as false positives).

**S5-alt — Orchestrated parallel execution (multi-item batches).** When the accepted plan is
a batch of INDEPENDENT items, don't execute inline: fan out to workers in parallel —
`coder` (Sonnet) for small specced fixes, `engineer` (Opus 5) for
structural work and spec'd feature builds, `test-writer` FIRST wherever touched code lacks
coverage. If the batch needed a fresh audit, fan that out too: parallel read-only `explorer`
passes, each owning a slice small enough to read IN FULL — precise findings (file:line,
evidence) are what make delegation briefs good; vague specs make workers improvise. Write
each worker a self-contained spec in four parts — delegation quality IS spec quality:
(1) **FACTS** — the audit findings it needs, file:line, PASTED in (workers verify drift,
never re-discover); (2) **OWNERSHIP + change** — the files it OWNS (touch nothing else),
the problem, the intended design; (3) **DECIDED** — design decisions already made and why,
so the worker implements instead of relitigating; (4) **HAZARDS + VERIFY** — known edge
cases to check and the exact verify commands. **One writer per file, ever** — sequence anything
that shares a file, or set `isolation: worktree` when ownership can't be split cleanly.
**Hub-file batching:** when the batch's items all funnel through one hub file (a monolith
daemon, a central router), don't serialize workers through it — give ONE worker a
multi-item spec for the whole batch; extra workers enter only for files the hub never
touches.
**You own git:** workers never run git write commands (`stash`, `checkout --`, `reset`,
`clean`, commit, push — a bare stash in a shared tree destroys other workers' in-flight
edits); you stage and commit between batches, and `git add` new files before any deploy step
that syncs tracked files. **Review cadence (below-Fable driver only — a Fable-tier
lead never spawns `reviewer`; it reads every worker diff itself, per the MODEL
GATE):** workers that ran in PARALLEL (worktrees or
disjoint files) each gate through `reviewer` before you merge them; a SERIAL batch in one
tree takes ONE `reviewer` pass over the combined diff at the end — same coverage, fewer
spawns. Tiny mechanical diffs (template-following, ≲30 lines, no new logic) skip the
`reviewer` spawn entirely: the lead reads the diff directly — faster than the spawn, and
the same first-hand eyes the user-facing rule already demands.
Either way you read verdicts, never raw diffs, with ONE exception: personally read
the diff of any NEW user-facing behavior first-hand regardless of verdict. Delegate
regression breadth, never novelty. Treat each worker report's **Concerns** section as
review agenda, not commentary — feed every named hazard to the `reviewer`/`smoke-tester`
pass or rule on it yourself; workers self-flag exactly what specs miss. **Amendments to a
worker's own diff resume the SAME worker** (`SendMessage` to its agent id) — its context is
warm and the turnaround is seconds; a fresh spawn re-pays the full read. REJECT is
different: re-delegate with a tighter spec, not a fix-it argument with the
worker. The merged diff then gets the single S6 warm review as normal. Keep DEPENDENT chains
inline: spawn overhead and lost shared context make sequential delegation slower than driving
it yourself, and speed is the only reason this alt exists. (In long multi-phase sessions,
lean toward delegating even single items past ~1 file / ~20 reasoned lines — context
leanness compounds, and full-file reading is cheap in a worker.)

**S6 — Warm review.** When the S4 precondition is met, resume the SAME `fable-planner` agent
with the warm review brief, **overriding effort down to `medium` per-invocation** (verified:
changing effort mid-conversation does not break the message cache). The review is bounded
judgment on a diff against an already-vetted plan — the open-ended reasoning was paid for at
plan effort. The S5 exception mid-consult takes the same `medium` override. **Resume-failure path:** if the handle is gone (session restart,
compaction), DISCLOSE to the user that the owed review can't be fulfilled and why. Do NOT
substitute a fresh Fable spawn — a cold spawn violates warm-only and re-bills the context the
resume was meant to reuse. **Degraded fallback:** spawn the `reviewer` worker (Sonnet) on the
diff + task spec and disclose the downgrade — a reviewed ship beats an
unreviewed one. Ship with the gap disclosed, or let the user decide.

**S7 — Apply MUST-FIX, self-verify, ship.** For each MUST-FIX: diff the fixed lines against
the item, confirm the fix addresses it, run the narrowest test that exercises it (inline, or
`verifier`). If the change altered runtime or user-facing behavior and the system can be
driven, spawn `smoke-tester` with one concrete scenario (trigger → expected observable →
timeout) before shipping — green unit tests are not the finish line. Ship on green. No
post-fix Fable touch — a MUST-FIX that genuinely can't be made to pass is disclosed to the
user, not sent back to Fable.

## Critique mode (opt-in only — user explicitly asked for a critique of YOUR plan)
Write a draft plan (5–15 lines), and write the line `REJECTED: <alternative> — <reason>`
for its load-bearing approach. If you CAN'T write that line (no runner-up, or no concrete
reason it lost), you have a first idea, not a chosen approach — tell the user and fall back
to default plan mode: critiquing a first idea launders your uncertainty into false
convergence. If you can, send the brief with sections 6–8 included: Fable spends its rate
on the failure modes of a structure you've already reasoned through, and the REJECTED line
stops it re-proposing the alternative you killed — its ENDORSE then means real convergence.
Verdicts here are ENDORSE / AMEND / REPLACE (AMEND = deltas onto your draft, unlisted steps
stand; REPLACE only when the draft is wrong end-to-end).

## Building the brief — this is where a consult lives or dies
Transfer conclusions, not context. Fable reads pointed-to files (≤8 reads) and delegates
search to a Sonnet `explorer` child, so point, don't dump — EXCEPT the load-bearing core,
which you paste.

**Lookup fence — run before the consult.** Scan the brief for any clause that is discovery /
lookup / "verify / check the docs" rather than judgment: Fable is never for finding facts.
Resolve each yourself (inline, or `explorer`) and replace it with the answer. Structural, not
felt: run it even when the brief looks clean.

**Plan brief** (target ≤3.5k tokens — input is Fable's cheap channel; spend it on evidence,
never on hints of approach), in this order — goal first, bulk in the middle, the
ask at the end:
1. INTENT — one line: the larger goal, why it matters, who it's for. Fable plans better
   knowing the goal, not just the request.
2. Task verbatim.
3. Session-only constraints Fable cannot discover from files (user prefs, prior decisions,
   scope boundaries) + `BASELINE:` from S0 + `DONE-MEANS:` — 2–5 observable acceptance
   criteria and invariants (tests that must stay green, behaviors preserved). Fully specify
   the WHAT; carry zero HOW — this section is the biggest accuracy lever in the brief.
4. File map — 3–10 abs paths, 1-line role each — plus a raw skeleton (≤40-line tree of the
   relevant dirs, uninterpreted) and `PRIOR ART:` — patterns this repo already uses for this
   kind of change, stated factually, not as recommendation.
5. Pasted load-bearing code ≤150 lines (the interfaces/schemas/functions being changed, with
   file:line headers).
6. 0–3 numbered questions you genuinely can't resolve from evidence (open design forks,
   unstated tradeoffs). Phrase them neutrally — a question that telegraphs your preferred
   answer anchors the plan you're paying Fable not to anchor.
7. *(Critique mode only)* `REJECTED: <alt> — <reason>`, then YOUR DRAFT PLAN, opened with
   "my draft view, for you to critique or replace".

The default brief carries ZERO approach content — no draft, no leading questions, no
"prior art" phrased as recommendation. Evidence in, plan out.

**Warm review brief** (resumed `fable-planner`; target ≤1.5k tokens + diff): ONLY what is new
since planning — deviations log · the diff (full if ≤400 lines; else --stat + risky hunks in
full) · verification evidence (command → result, one line each) · 1–3 concerns. No stance
line (the agent prompt carries review stance); never re-send the plan, file map, or pasted
code — the agent holds them, and re-sending is the waste warm mode exists to avoid.

A brief missing the session constraints or DONE-MEANS is a wasted engagement — Fable will
plan against a false or vague premise and you'll deviate your way back to your own judgment.

## Batch mode (≤3 small related items)
Thinking bills at output rate per ENGAGEMENT, so N tiny engagements pay that overhead N
times. When several small items share a subsystem, send ONE plan brief carrying T1/T2/T3
blocks: each block = task verbatim + its DONE-MEANS. Shared file map, constraints, and
pasted code appear once. Fable returns one `T# PLAN:` block per task, steps referenced as
`T#S#`. Execute all (S5 or S5-alt), then ONE warm review over the
combined diff — deviations and hunks labeled by T#. Never batch items that interact: a
cross-item flaw needs one plan, not a batch.

## Review-only mode (mechanical, pre-approved items)
For items where a plan consult buys nothing — dead-code removal, renames, dependency bumps
you've already decided — skip the consult machinery: execute (or delegate to a worker), then
spawn `fable-planner` COLD with a review-only brief: task spec, diff, verification evidence,
and the literal marker `REVIEW-ONLY`. Warm-only doesn't apply — there is no planning context
to reuse. Effort override `medium`. Returns the normal SHIP / FIX-THEN-SHIP block. Cheaper
still: route genuinely trivial diffs to the Sonnet `reviewer` worker and spend zero Fable.
The tiering, so the same diff is never double-reviewed by default: trivial → `reviewer`
only; mechanical-but-worth-Fable → review-only; anything that got a plan consult → warm
review only.

## Reading Fable's coded output
Fable replies in a coded, exception-based format because its OUTPUT bills at 5× its input
($50/MTok) — output is the expensive channel, and these codes are where the savings live:
- Codes (NIL/BOUND/RACE/AUTHZ/VALID/ERRPATH/INVARIANT/LEAK/TYPE/DEADCODE/REGRESS/PERF +
  plan-level SEQ/SCOPE/SIMPLER) are the SAME table Fable's prompt defines — expand each to
  its fault class yourself. A `FREE:` line is already plain.
- **Integrity check first:** every valid reply ends with a literal `END` line. No `END` ⇒
  the reply is truncated or the call silently fell back (see below) — treat all silences in
  it as unreliable, never as endorsement.
- Given `END` is present: silence = accept. No MUST-FIX line ⇒ SHIP; a deviation absent from
  DEVIATION AUDIT ⇒ ACCEPTED; no PLAN AUDIT line ⇒ the plan held; empty RISKS/ASSUMPTIONS ⇒
  none. Never re-ask Fable to "confirm the rest is fine" — that confirmation is the silence.
- The plan engagement returns `PLAN:` numbered steps (`S# imperative (files)`), plus answers
  to your numbered questions and any RISKS / CHECKPOINTS / ASSUMPTIONS. That plan IS the
  plan of record; `S#` everywhere after (checkpoints, deviations, review) references it.
  (Critique mode only: verdicts are ENDORSE / AMEND / REPLACE; AMEND emits deltas onto your
  draft, unlisted steps stand, and `S#` references your draft.)
- References are pointers into context YOU hold: `S#` = a plan step, `H#` = a
  diff hunk, `D#` = a logged deviation. Resolve them against your own copy.
- A line is one finding: `path:line CODE imperative` (plan-level codes reference `S#`). A
  genuinely undecodable line (not just terse) is the ONE case for a RECONSULT — read the
  FREE: escape first.

## Bindingness & tie-breaks
- Fable's plan is the default. Deviate freely — but log every deviation; it gets audited at
  review.
- A plan point or MUST-FIX resting on a listed ASSUMPTION you know is false is void. Plan
  points: note it in the deviations log and proceed. MUST-FIX: you may override, but you
  MUST tell the user ("Fable flagged X; overriding because Y").
- All other MUST-FIX items are binding. SHOULD-FIX is your call.
- RECONSULT = your brief was insufficient to JUDGE (missing context, not missing fixes).
  Answer it inside engagement 2: one follow-up `SendMessage` with exactly what Fable asked
  for. No code changes between the RECONSULT and its answer, or it becomes a banned
  post-change re-review.
- After MUST-FIX, you do NOT re-consult (S7).

## Never consult Fable about
- **Intent ambiguity** — Fable has no access to the user's intent and would guess in
  output tokens, its most expensive channel. Two divergent readings where the wrong pick costs a redo: ask the USER one line.
- **Silent-fallback domains.** Two things trip Fable 5's classifiers, and a refusal
  (`stop_reason: refusal`) silently falls back to Opus 4.8 — you get Opus judgment while
  believing you consulted Fable: (1) any brief wording that asks Fable to echo, transcribe,
  or explain its internal reasoning ("show your thinking / why you concluded X" — the coded
  findings format is safe: it compresses conclusions, not thinking); (2) offensive-security
  work (exploits, malware, attack tooling — even benign hardening tasks can trip it) and
  biology / life-sciences content — keep those tasks off `/fable` entirely. The missing
  `END` line is your mechanical detector for a fallback that slipped through.
Pliki w paczce (2)
  • LEAD.md 3 KB
  • SKILL.md 19 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · casualsav/fable-bench90MIT
mickeyyaya/evolve-loop100Apache-2.0
noahdunnagan/cafe100MIT

Migawka bazy z 13.11.2026 · wersja paczki deb451b33187 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100optimize-claude-fable-5-prompts
    Wyjaśnia i przepisuje prompty dla Claude Fable 5 przy optymalizacji, migracji, debugowaniu lub projektowaniu promptu Fable 5.
  • 90fableplan
    Włącza tryb planowania w modelu Fable 5 i wykonania w Sonnet, z opcją wyłączenia lub kontekstu 1M.
  • 90prompt-fable
    Przygotowuje gotowy do wklejenia prompt dla Claude Fable 5 bez uruchamiania zadania, np. do użycia w aplikacji webowej, innej sesji albo przez kolegę.
  • 85fable-review
    Uruchamia niezależny przegląd kodu Fable i zwraca go bez zmian, wyłącznie na wyraźne wywołanie użytkownika.
  • 100fable-advisor
    Wykonuje zadanie modelem bieżącej sesji pod nadzorem stałego doradcy Fable 5.1: plan i konsultacje przez subagenta tylko do odczytu oraz wiążący werdykt recenzenta przed commitem.
  • 90fable-mode
    Wymusza na modelu pięć bramek pracy: zakres, dowody, kwestionowanie własnych wniosków, weryfikację i rzetelny raport.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.