← research

Fable Salvage — operational playbooks for the final ~34h (sweep 2026-07-07)

Jul 14, 2026

Narrow, operational follow-up to ~/Developer/claude-mission-control/docs/RESEARCH_fable_rush.md (read that for the broad landscape). This doc = exact prompts / artifact shapes / routing consensus to RUN TONIGHT.

STATUS: COMPLETE (sweep finished 2026-07-07 ~02:30 PT). Raw source files cached alongside this doc (tw_*.yaml, th_*.yaml, rd_*.yaml, improve_*.md, trq_article.md, exm_article.md, theo_claudemd.jpg, miles_prompt.jpg).

RANKED PLAYBOOKS

PLAYBOOK #1 — The VoicuDragomir rewrite of the retiring-engineer prompt (BEST-IN-CLASS variant found)

Source: @VoicuDragomir, Jul 5 2026, reply to @PrajwalTomar_'s viral thread — x.com/VoicuDragomir/status/2073839391164780728 (13yr web dev, 200+ projects). This is the refined descendant of the tomicz shape, rewritten after field-running heavy multi-agent sessions.

Why it beats the tomicz original (his critique, verbatim):

  • "The 'aim for 10-16 skills' line does real damage. Give a model a count and it pads to hit it, and the padding is where invented commands come from. Drop the number. Let it write what the repo earns and delete any category it'd have to fabricate to fill."
  • "'Verify every command against the repo' can't be enforced by asking nicely. A model verifies only if it runs the thing… So I make it tag every claim by how it knows: ran it, read it, or guessed. Then the factual reviewer downgrades any 'verified' that was never executed. Without that step the review is theater."
  • "Blind agents can't see each other, so the same fact gets written twice with different details and half the cross-references point at nothing. What works for me: one explorer pass builds a single fact index, one owner per fact, then authoring runs against that."
  • "Skills load on demand when a task matches the description, so release history and 'external positioning' never get triggered by anything and just sit there dead. That belongs in docs. Always-on conventions go in CLAUDE.md. Decide the artifact type before writing a line and three of these stop being skills."

FULL PROMPT, VERBATIM:

You are documenting a codebase so cheaper models (Haiku/Sonnet-class) and mid-level engineers can debug, extend, validate, and operate it without you. Build a skill library under .claude/skills/ plus supporting docs. Correctness over coverage. Write only what the repo justifies. Use multi-agent orchestration, but read the orchestration rules below before spawning anything.

PHASE 1: Investigate before writing (no authoring yet) Read like an incoming principal engineer: README/manifest/contributor docs, the build system, the test suite and how it is actually run, CI config, docs dirs, git history (what changed, what got reverted, what stalled on dead branches), TODO/FIXME hotspots, issue-shaped artifacts, deploy conventions, project notes. Then ask me AT MOST five questions, only for what the repo cannot tell you: (1) hardest live problem right now, (2) unwritten discipline rules no doc states, (3) who the audience is and what they do NOT know, (4) what past failures cost the most time, (5) what "good" means here. Fold my answers into everything below.

PHASE 2: Classify artifact type, then author Before writing any fact, classify it:

  • Procedural "how to do X" that a task would trigger -> skill in .claude/skills/
  • Convention needed regardless of task -> CLAUDE.md
  • Archival record with no task trigger (release history, external positioning) -> docs/ Skills load on demand by description match. Content with no task trigger will never fire, so do not force archival or always-on content into skills.

Author only the skills the repo justifies. NO target count. If you would have to invent content to fill a category, delete the category. A normal app is usually 6-12 skills; more only if the repo is genuinely that deep.

EVIDENCE DISCIPLINE (every command, flag, path, and factual claim): Tag how you know it: [verified: executed] / [read: from ] / [inferred: unconfirmed] Never write [verified] for anything you did not run. A runbook that reads as verified but was not executed is worse than no runbook.

TAXONOMY (adapt: merge thin categories, split deep ones, add domain categories the repo needs): CORE

  • change-control: how changes are classified/gated/reviewed here; the non-negotiables with rationale and the incident behind each.
  • debugging-playbook: symptom -> triage table for this repo's real failure modes; the traps that cost time, each with its story; discriminating experiments.
  • failure-archaeology: chronicle of major investigations, dead ends, rejected fixes, reverts as symptom -> root cause -> evidence -> status. Frame the description so it loads during debugging, or it will never trigger. Mine git history hard.
  • architecture-contract: load-bearing design decisions and WHY; invariants that must hold; known weak points stated plainly.
  • config-and-flags: every config axis, defaults, production vs experimental, guards; how to add one (checklist); re-verification commands, since flags drift.
  • build-and-env: recreate the environment from scratch; known traps.
  • run-and-operate: running/deploying; command anatomy; where output lands.
  • diagnostics-and-tooling: how to MEASURE instead of eyeball; ship real scripts in scripts/ where they exist or you can write them, with interpretation guides.
  • validation-and-qa: what counts as evidence; acceptance thresholds; the golden/certified inventory; how to add tests.
  • domain-reference: the domain knowledge a mid-level person lacks, as it applies HERE, not a textbook.

ADVANCED (include only what fits THIS repo)

  • incident-campaign: for the hardest live problem from Phase 1, an executable decision-gated runbook: numbered phases, exact commands, EXPECTED output at each gate ("if you see X instead -> go to Y"), a ranked solution menu with the reasoning obligation for each, known wrong paths fenced off, and a promotion path that routes through change-control. Success measured, never eyeballed.
  • Add research-frontier, research-methodology, proof-and-analysis-toolkit, or external-positioning ONLY if this repo's actual goal is advancing state of the art. For a product or app repo, skip them entirely.

AUTHORING RULES (bake into every agent)

  • Audience: zero-context mid-level engineer or Sonnet-class model. Imperative runbook voice, copy-pasteable commands, define each jargon term once, tables and checklists.
  • Every skill states when NOT to use it and which sibling to use instead.
  • Format: .claude/skills//SKILL.md, YAML frontmatter with name and a trigger-rich description (exactly when to load it).
  • One home per fact. Cross-reference elsewhere, never duplicate.
  • Date-stamp volatile facts; end each skill with a "Provenance and maintenance" section: one-line re-verification commands for anything that drifts.
  • Unproven things stay labeled candidate/open. Nothing contradicts the manifest. No skill routes around change-control.
  • Write ONLY inside .claude/skills/ and docs/. The rest of the repo is read-only. No mutating git commands.

ORCHESTRATION Do NOT spawn parallel agents that each author a skill blind; they duplicate facts and produce inconsistent cross-references. Instead:

  1. One explorer pass builds a shared fact index: every fact, its evidence tag, and the single skill that owns it.
  2. Author sequentially, or parallel only after ownership is assigned, each agent reading the shared index so no fact is written twice. This also removes the coordination gap: isolated agents share no state, so without a single index they cannot know what a sibling already wrote.

PHASE 3: Review then fix (after ALL skills exist) Three parallel reviewers, then one fixer:

  • FACTUAL: re-verify flags/paths/commands. Downgrade any [verified] tag that was not actually executed to [read] or [inferred]. Flag invented or stale content by severity: would it send an engineer down a wrong path?
  • DOCTRINE: contradictions with repo rules or between skills; overstated claims; anything that changes behavior but is not gated.
  • USABILITY: description trigger quality, duplication (one home per fact), self-containedness, scannability. Fixer applies blocking and important fixes. Then give me: the inventory with one-line descriptions, what was verified by execution vs only read, and what remains uncertain.

What it produces: 6-12 evidence-tagged skills + CLAUDE.md conventions + docs/, with a review pass that downgrades unexecuted "verified" claims. Quota cost: tomicz-shape field reports = ~30% of weekly Fable allowance; one Brazilian user (@SfJokerStfu) reported 60% burned and still in Phase 2 on the original. The Voicu rewrite's sequential-after-index orchestration should cost LESS than the blind-parallel original (no duplicate authoring), but Phase 1 (git-history mining) is the expensive part. ADAPTATION NOTE (this setup): We already have Mission Control's dead-skill/cache/doctrine audits — SEED Phase 1 with those outputs instead of letting Fable re-derive them (feed it: the 95-never-fired skill list, trigger-phrase audit, SubagentRollup doctrine findings). That converts Phase 1 from an expensive discovery pass into a cheap confirmation pass. Also: with 110 existing skills the play is NOT authoring more skills — run Phase 2's artifact-type classifier AGAINST the existing catalog (skill vs CLAUDE.md vs docs vs delete) — see Playbook #3.

PLAYBOOK #2 — diegocabezas01's orchestration doctrine (the routing config to persist)

Source: @diegocabezas01 (Data Scientist, Chase), Jul 1 2026 — x.com/diegocabezas01/status/2072436501263339841 — 5,063 likes / 602k views, the most-endorsed concrete routing config of the window.

FULL SETUP, VERBATIM:

Fable 5 (max reasoning) = orchestrator Opus = deep reasoning subagent Sonnet = mechanical work subagent Codex = peer Sr. engineer, different perspective

  1. Set Fable 5 as your main model. In Claude Code: /model → Fable 5 → reasoning /effort to max
  2. Create 2 subagents with /agents: deep-reasoner → pinned to opus "Use for reasoning-heavy phases, architecture, debugging complex issues, algorithm design. Think thoroughly, return a concise conclusion the orchestrator can act on." fast-worker → pinned to sonnet "Use for mechanical tasks, boilerplate, tests, formatting, simple edits. Execute efficiently."
  3. Add OpenAI's official Codex plugin: /plugin marketplace add openai/codex-plugin-cc ; /plugin install codex@openai-codex ; /codex:setup
  4. Drop this in your CLAUDE.md:

    Orchestration workflow

    You (Fable) are the orchestrator. Plan, decompose, synthesize. Reasoning-heavy phases → deep-reasoner Mechanical work → fast-worker Codex (/codex:rescue --background) is a cracked engineer on par with deep-reasoner, from a different perspective. Treat as a peer, not a reviewer. High-stakes decisions: task Opus + Codex on the same problem in parallel, synthesize the best of both, without showing either the other's answer. Keep your own context lean.
  5. Then prompt Fable like a tech lead: "Goal: [what you want] Context: [files, constraints] You're the lead. Delegate reasoning to deep-reasoner, grunt work to fast-worker, fresh-perspective problems to Codex. Show me your plan first, then execute."

ADAPTATION NOTE: This user's global CLAUDE.md already encodes 90% of this (Fable=main-loop-only, Opus pins, fleet delegation, codex plugin installed). The two NEW pieces worth stealing tonight: (a) the "Treat as a peer, not a reviewer" framing for Codex, and (b) the "task Opus + Codex on the same problem in parallel, synthesize without showing either the other's answer" high-stakes pattern — neither is in the current doctrine. Post-cutoff, swap "Fable" → "Opus 4.8" as orchestrator and keep the rest verbatim.

PLAYBOOK #3 — "THE SKILL AUDIT PROMPT" (@aiedge_ / shared by @milesdeutscher) — the skill-hygiene pass

Source: @milesdeutscher, Jul 6 2026 — x.com/i/status/2074168233322741823 (104 likes / 27k views). Prompt card by @aiedge_; image decoded in full (https://pbs.twimg.com/media/HMjtBCfaYAIKoMz.jpg). Verbatim framing: "Run this prompt inside Fable, attach your old Opus 4.8 skills, and have Fable optimise them. This guarantees that your old Claude skills give the best possible output once Fable is gone."

FULL RUBRIC (transcribed from the card):

Task: attach your custom SKILL.md files. Claude reviews every one and returns an optimized version of each, plus a summary of what changed and why.

WHAT TO CHECK, PER SKILL: 01 TRIGGERING ACCURACY — Enough concrete trigger phrases, or vague enough to get missed/misfire? Overlaps with another attached skill? Should it state what it's NOT for? 02 INSTRUCTION CLARITY — Could zero-context Claude follow it and get it right first try? Implicit assumptions never actually stated? Workflow unambiguous, or leaning on judgment calls? 03 REDUNDANCY + BLOAT — Anything repeated across sections or sayable in half the words? Examples that add nothing beyond the rule itself? 04 EDGE CASES — What happens on a malformed/incomplete input? Covered? Do skills conflict when run in sequence? 05 OUTPUT SPECIFICATION — Is the exact expected output stated explicitly — format, length, tone, include/exclude?

WHAT TO PRODUCE:

  1. Inventory — one-line summary of each skill's purpose, before changing anything
  2. Optimized version of each skill — rewrite the DESCRIPTION first (it drives triggering), then the body only where it fails a check above
  3. Changelog per skill — what changed and why, in a few lines
  4. Conflicts — flag overlaps or contradictions rather than quietly resolving them. That's your call, not Claude's
  5. Summary table — skill name, main issue, fix applied, confidence (high/medium/low). If a skill is already solid, say so instead of inventing a problem

PRESERVE: each skill's core purpose and brand-specific content, exactly; the existing tone and structure; anything that already works — don't touch it. RULES: Optimize the mechanics, not the substance. Never invent a problem to justify a change. Never use em dashes.

What it produces: rewritten descriptions (the triggering surface) + surgical body fixes + a conflict list you adjudicate — the closest published match to this user's actual need (110 skills, 95 never fired). Quota cost: scales with attached skill bodies. Descriptions-first batching keeps it cheap. ADAPTATION NOTE: Merge with Voicu's Phase 2 artifact-type classifier for the full treatment: batch the 110 skills' DESCRIPTIONS only (plus Mission Control's dead-skill/fire-count audit as ground truth of which never trigger), have Fable (1) reclassify each as skill/CLAUDE.md/docs/delete, (2) run checks 01+03 on all, (3) request full bodies only for keepers that fail 02/04/05. The "rewrite the description first (it drives triggering)" line is the single highest-leverage instruction for the 95-never-fired problem. Also keep "If a skill is already solid, say so instead of inventing a problem" — prevents churn across a 110-file catalog.

PLAYBOOK #1b — shadcn's /improve skill: "drain intelligence into a plan backlog" (INSTALLABLE, zero prompt-engineering needed)

Source: @shadcn — x.com/i/status/2064671802509410806 (Jun 10, 6,300 likes / 805k views) + doubling-down post x.com/i/status/2065826989769163068 (Jun 13, 7,230 likes): "A frontier model got pulled. If it happened once, it's gonna happen again. Fable today. 4.9 tomorrow or maybe gpt 6 one day. So, treat intelligence as borrowed. Drain intelligence when it's available. Build a catalog of plans today. Then implement later with a cheaper, open source, or a model you control. Build the backlog now." Repo: github.com/shadcn/improve — install: npx skills add shadcn/improve (also a Claude Code plugin via .claude-plugin/marketplace.json). MIT.

What it is: an agent skill where the expensive model NEVER implements — "The plan is the product." Modes: /improve (full audit → findings table → you pick → plans), /improve quick, /improve deep, /improve security|perf|tests|bugs, /improve branch (scoped to current branch), /improve next (feature directions, evidence-cited), /improve plan <desc>, /improve review-plan <file>, /improve execute <plan> (dispatches a cheaper executor in an isolated worktree, reviews the diff against the plan, reports verdict), /improve reconcile (verify/unblock/retire backlog), --issues (publish plans as GitHub issues). Pipeline: Recon (stack + exact build/test/lint commands, ingests ADR/PRD/CONTEXT.md so decided tradeoffs aren't re-flagged) → Audit (parallel subagents across 9 categories, every finding carries file:line evidence/impact/effort/confidence) → Vet (advisor re-reads every cited location itself; false positives dropped, rejections RECORDED so they don't come back next run) → Prioritize (impact ÷ effort weighted by confidence) → Plan.

The plan-template is the keeper artifact shape (full file cached at scratchpad/improve_plan-template.md). Three properties that make a plan executable by a weaker model, verbatim:

  1. Self-contained context — everything needed is in the file: paths, code excerpts, conventions, commands.
  2. Verification gates — every step ends with a command and its expected result. The executor never has to judge whether it succeeded.
  3. Hard boundaries and escape hatches — explicit out-of-scope list, and "STOP and report" conditions instead of letting the model improvise when reality doesn't match the plan. Plus: a drift check run first (git diff --stat <planned-at SHA>..HEAD -- <in-scope paths> — mismatch = STOP), machine-checkable Done criteria, a plans/README.md index with status rows AND a "Findings considered and rejected" section ("So nobody re-audits it"), and a quality bar: "Could a model that has never seen this repo execute this with only the plan file and the repo?"

Quota cost: /improve quick exists precisely to keep it cheap; full audit = fan-out (watch the 96-agent failure mode from the prior sweep — cap concurrency). ADAPTATION NOTE: This is the highest-leverage RUN-TONIGHT item for repos (rally, foreman, mission-control): install the plugin, run /improve per repo on Fable, bank plans/ directories. Post-cutoff, Sonnet/Opus (or GLM per fleet doctrine) execute from the backlog with /improve execute. The plan-template ALSO doubles as the shape for tonight's CLAUDE.md decomposition doctrine: verification-gates + STOP-conditions + out-of-scope lists are exactly the "verification habits, decomposition rules" the user wants Opus/Sonnet to inherit. Files cached locally: improve_readme.md, improve_plan-template.md, improve_audit-playbook.md, improve_closing-the-loop.md.

PLAYBOOK #4 — kaize one-liner + the caveat cluster (cheap fallback, run only if quota-starved)

Source: @0x_kaize Jul 5 (1,242 likes/314k views) — already in prior sweep; variants surfaced since:

  • @Oluwaphilemon1 / @alex_prompter variant (Jul 6): "Write a SKILL.md that teaches a smaller model to work the way you work on this project. Document how you break problems down, what you verify before answering, which mistakes you avoid, and how you structure output. Be specific enough that another model can follow it without you." — the "on this project" grounding makes it less generic than kaize's.
  • Honest caveat now circulating with it (@alex_prompter): "A skill file doesn't transfer raw capability, so Opus 4.8 won't suddenly reason at Fable's level. What it does transfer is process. You keep the decomposition habits, the self-checks, and the answer structure." Quota cost: single-session, minutes — the cheapest playbook here. ADAPTATION NOTE: run once per HARD project (rally, foreman, mission-control), inside a session where Fable has just done real work — not cold.

PLAYBOOK #5 — trq212's "Finding Your Unknowns" field guide (FIRST-PARTY Anthropic doctrine; fold into fable-judgment skill)

Source: @trq212 (Claude Code @ Anthropic), X Article "A Field Guide to Fable: Finding Your Unknowns" — linked from x.com/trq212/status/2073100352921215386 (Jul 3, 8,288 likes / 2.9M views). Full text cached at scratchpad/trq_article.md. @RohOnChain's framing: "an Anthropic engineer just gave the exact prompting playbook for Fable 5."

Core thesis, verbatim: "Fable is the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns… reducing and planning for your unknowns is the skill of agentic coding." Frames everything as known knowns / known unknowns / unknown knowns / unknown unknowns.

The pattern menu (each with his exact example prompts, all model-agnostic — this is CLAUDE.md/skill material):

  1. Blind Spot Pass (pre-implementation): "Can you do a blindspot pass to help me figure out my relevant unknown unknowns and help me prompt you better." — he uses the literal words "blindspot pass" and "unknown unknowns."
  2. Brainstorms & prototypes: "Make me an HTML page with 4 wildly different design directions so I can react to them." / "Before wiring anything up, make a single HTML file mocking the new editor toolbar with fake data." / "Search the codebase and brainstorm 10 places we could intervene, from cheapest to most ambitious. I'll tell you which ones resonate."
  3. Interviews: "Interview me one question at a time about anything ambiguous, prioritize questions where my answer would change the architecture."
  4. References: "the absolute best reference is source code… point Fable at the folder and tell it what to look for, even if it's in a different language."
  5. Implementation plans: "Write an implementation plan… but lead with the decisions I'm most likely to tweak: data model changes, new type interfaces, and anything user-facing. Bury the mechanical refactoring at the bottom, I trust you on that part."
  6. Implementation notes (during): "Keep an implementation-notes.md file. If you hit an edge case that forces you to deviate from the plan, pick the conservative option, log it under 'Deviations', and keep going."
  7. Quizzes (post): "Give me a HTML report on the changes… and a quiz at the bottom on the changes that I must pass." — "I only merge after I pass the quiz perfectly."
  8. Closing: "Every explainer, brainstorm, interview, prototype, and reference is a cheap way to find out what you didn't know before it gets expensive to fix."

ADAPTATION NOTE: This is NOT Fable-specific — it's the operator-side complement to skill extraction, and it's first-party. Cheapest playbook here (no Fable tokens needed at all: the artifact already exists). Tonight: fold patterns 1/3/5/6/7 into the existing fable-judgment skill (they're exactly its "decomposition, self-verification, next-action decisions" mandate), and put the interview + implementation-notes-with-Deviations patterns into CLAUDE.md as standing behavior for Opus/Sonnet sessions.

PLAYBOOK #6 — EXM7777's "Do this on your last day with Fable" 5-move system (incl. the extract-approach RECORDER skill)

Source: @EXM7777 X Article "Do this on your last day with Fable" — x.com/EXM7777/status/2074158459545854232 (Jul 6, 665 likes/122k views; earlier edition 1,068 likes/670k views). Full text cached at scratchpad/exm_article.md. NOTE: the paste-ready prompts are in embedded images the API doesn't return — structure and rules below are complete, exact prompt texts are not.

The ranking test, verbatim: "one question sorts everything you could do today: can a cheaper model redo this tomorrow? … what a cheaper model can't redo tomorrow is anything that requires fable-level judgment to create but only ordinary intelligence to use: a standard written down, a roadmap already reasoned through, a knowledge vault already distilled, a skill that fires on its own."

The 5 moves (his priority order if time is short: 5 → 4 → 1 → 2 → 3):

  1. Plant judgment in the workspace — Fable rewrites CLAUDE.md + skills as checkable standards: "a cheaper model can't invent a quality bar, but it applies a written one fine."
  2. Consultant audit — Fable-as-consultant writes a ranked roadmap + stop list over your projects/numbers: "tomorrow opus doesn't need to be brilliant, it needs to follow a brilliant document."
  3. Second brain run — deep-research volume, mined into an atomized vault: "don't summarize into one long report… atomize. a hundred linked one-insight notes get retrieved and reused, a 40-page report gets stored and forgotten."
  4. Fire the goals — /goal + dynamic workflows on the highest-value backlog. TWO SAFETY RULES, verbatim: "demand pasted proof in the finish line: the judge model reads only the conversation, it can't run your tests or open your files, so the condition asks for the green run pasted, never promised" and "cap every run: turns or wall-clock, written into the condition, one unattended loop without a cap billed $6,000 by morning." Plus: "fable burns weekly limits roughly twice as fast as opus, and only half your weekly limit applies to it… pick the two or three goals with the most locked-up value, not ten."
  5. The extract-approach recorder skill — create .claude/skills/extract-approach/SKILL.md, wire it into CLAUDE.md so it fires unprompted: "every time fable cracks a hard problem today, its approach evaporates when the session ends. this move installs a recorder… every solve leaves a note behind, and the notes are the distillate: fable's reasoning, sitting in your repo, readable by every model that comes after. this is the compounding move, and it's also the one to install FIRST if you only have an hour."

ADAPTATION NOTE: Move 5 is the prospective version of transcript-mining: instead of (or in addition to) mining 5.3k old sessions, install the recorder NOW so tonight's remaining Fable hours self-document. This user already has /learn (project learnings) and the Dreaming Ledger — the recorder is a thin CLAUDE.md rule: "after solving any hard problem, append a one-insight learnings note (approach, discriminating evidence, dead ends) before reporting done." Move 3's "atomize, don't summarize" maps to gbrain conventions verbatim. Move 4's two safety rules should go into CLAUDE.md permanently (they apply to /goal + loop + scheduled agents regardless of model).

Cautions attached to Playbook #1-class runs (field-reported)

  • @GMASMROfficial (Jul 5): "the newest models write more abstract skills… that earlier models have trouble with. I've gotten to the point where I have to explicitly ask it to dumb down whatever skills it's writing for other agents that are not fable or GPT 5.5." → keep Voicu's "Audience: zero-context mid-level engineer or Sonnet-class model" line in every extraction prompt.
  • @UncleJAI (Jul 6): "make Fable write the tests and failure cases for those replacement skills too. Otherwise you keep the style of its judgment, but lose the acceptance surface that tells the next model when it is wrong."
  • @dvsj_in pushback stands (prior sweep): Fable-authored skills not guaranteed better than Opus-authored; "rank #1 [skill] missed a sev0… We still need to read code."
  • @atastaai: skill libraries should be "versionable and executable as diffs against new model releases" — re-run audits when Opus/Sonnet get major updates.

PLAYBOOK #7 — Rabello_quo's "Multi-Model Agent Hierarchy Planner" (the harness dial-in prompt: hooks + agents + CLAUDE.md audit)

Source: u/Rabello_quo, r/ClaudeCode "Try this before July 7!", Jul 4 2026 — reddit.com/r/ClaudeCode/comments/1umgudg/ (low score but the most complete harness-audit prompt found; full verbatim text cached in scratchpad/rd_routing.yaml lines 115-413). What it is: a /plan-mode prompt with a fill-in config block (PRIMARY_MODEL / EXECUTOR_MODEL / BUDGET_MODEL / ADVISOR_MODEL / EXTERNAL_TOOL / PRIORITY_ORDER / PLAN_CONTEXT). Claude then: (1) inventories settings.json, .claude/hooks/, .claude/agents/, CLAUDE.md, skills, env vars (incl. CLAUDE_CODE_SUBAGENT_MODEL silently overriding frontmatter); (2) diagnoses conflicts with existing hooks/rules; (3) proposes named task PROFILES (model+effort per agent, advisor pairing, entry criteria, fallback mode when PRIMARY is unavailable — directly the post-Fable case); (4) asks per-agent autonomy questions and STOPS for answers before drafting; (5) implements nothing. Doctrine lines worth stealing verbatim:

  • "Implement guardrails as hooks, never as prompt instructions. Prompt instructions fail under context pressure. Hook enforcement does not." (hard cap on subagents per session; 1 subagent per sub-topic never per search result; query dedup before new searches)
  • "Subagent frontmatter supports an 'effort' field that overrides the session level for that agent only… Do not assign high or max to every agent — justify each value against the priority order. BUDGET_MODEL at low effort for extraction is almost always correct."
  • "Every profile needs a fallback mode for when PRIMARY_MODEL is unavailable. Do not just swap the main model without rethinking the advisor pairing."
  • "Include at least one profile where EXECUTOR_MODEL is the orchestrator by design, not just as fallback." ADAPTATION NOTE: This is the tightest match for "have Fable tighten my Claude Code SYSTEM" — it audits the harness itself, not a codebase. Run it ONCE tonight against ~/.claude (global) with PRIORITY_ORDER = quality > tokens > speed. Its two-delivery stop-and-wait structure keeps Fable from burning quota on unapproved drafts. The "guardrails as hooks, not prompts" principle should be applied to the user's mass-subagent doctrine (currently prose in CLAUDE.md — a PreToolUse hook capping Agent spawns would enforce it mechanically).

PLAYBOOK #8 — the tiered-workflow repo ("saving me millions of Fable tokens" — post-cutoff shape, swap Fable→Opus)

Source: u/sideshowwallaby, r/ClaudeCode, Jul 6 2026 (21 pts) — reddit.com/r/ClaudeCode/comments/1uozzqf/ ; repo: github.com/orionmilos0-jpg/fabletieredworkflow (docs/workflow/TIERED-AGENTS.md has the rationale + diagram). Reported result: "I let a project run all night and it only cost me about $20. It normally would have cost me $3-400 in Fable tokens...at least." Shape: native subagents, each pinned: Architect (Fable — plans, decomposes, writes handoff packages, final eval, NEVER writes code so its context stays clean) / Developer (Opus — implementation + build/fix/retry loop) / Test-writer (Sonnet — boilerplate tests, mocks, fixtures) / Reviewer (Fable — reads diff + worker reports + Codex findings, structured verdict, read-only) / Codex (independent second-opinion reviewer, different model family "so it catches different bugs"). The two make-or-break disciplines, verbatim: "explicit handoffs (the architect must pass a Definition of Ready before routing, or a cheaper worker will confidently wander down the wrong path) and a boring shared run log (handoffs/RUN-STATE.md, updated by every tier) so the reviewer reads what happened instead of reconstructing it from chat." Classifier gotcha: he removed the security agent because "that kept making Fable fall back to opus" — security-phrased subagents trip the classifier (matches the user's existing "skip the classifier tax" doctrine). ADAPTATION NOTE: post-cutoff this is the doctrine with Opus in the Architect/Reviewer seats and Sonnet as Developer. The two disciplines (Definition-of-Ready gate + shared RUN-STATE.md run log) are CLAUDE.md-able tonight in one paragraph and are the pieces the user's current fleet doctrine lacks.

CAUTION — silent UPWARD routing is draining Fable quotas right now

u/tandembicyclegang, r/ClaudeCode (Jul 5, GitHub issue anthropics/claude-code#74245): selected Sonnet 5 via /model, statusline said Sonnet, system prompt said Sonnet — but "the API response metadata says Fable for literally every turn"; 90% of Fable weekly quota consumed by a pitch-deck session. Sessions flipped on Jul 2 (the redeploy day). "Silent upward routing from Sonnet to Fable, with the UI still claiming Sonnet, is documented nowhere." Implication tonight: verify per-message message.model in transcripts (Mission Control already parses this) before assuming quota math; the planned Opus-fallback detector should flag BOTH directions.

POST-CUTOFF ROUTING CONSENSUS

theo's (t3.gg) CLAUDE.md routing section — the most concrete post-Fable routing artifact found

Source: @theo, Jul 2 2026 — x.com/theo/status/2072482460122964067 (image decoded in full from pbs.twimg.com/media/HMLvRFoawAAes0k.jpg). Amplified by @BHolmesDev (Warp): "Absolutely sold on Fable for discussion + delegation, and GPT 5.5 for implementation using subagents." theo's outcome claim: "I was throwing away ~50% of my end-to-end agent-driven PRs before building this workflow. I haven't had to close a single one today."

VERBATIM (his CLAUDE.md "## Picking the right models for workflows and subagents"):

Rankings, higher = better. Cost reflects what I actually pay (OpenAI has really generous limits), not list price. Intelligence is how hard a problem you can hand the model unsupervised. Taste covers UI/UX, code quality, API design, and copy.

model cost intelligence taste
gpt-5.5 9 8 5
sonnet-5 5 5 7
opus-4.8 4 7 8
fable-5 2 9 9

How to apply:

  • These are defaults, not limits. You have standing permission to override them: if a cheaper model's output doesn't meet the bar, rerun or redo the work with a smarter model without asking. Judge the output, not the price tag. Escalating costs less than shipping mediocre work.
  • Cost is a tie-breaker only; when axes conflict for anything that ships, intelligence > taste > cost.
  • Bulk/mechanical work (clear-spec implementation, data analysis, migrations): gpt-5.5 — it's effectively free.
  • Anything user-facing (UI, copy, API design) needs taste >= 7.
  • Reviews of plans/implementations: fable-5 or opus-4.8, optionally gpt-5.5 as an extra independent perspective.
  • Never use Haiku.
  • Mechanics: gpt-5.5 is only reachable through the Codex CLI — codex exec / codex review (my ~/.codex/config.toml defaults to gpt-5.5). Use the codex-implementation, codex-review, and codex-computer-use skills; for work they don't cover (investigation, data analysis), run codex exec -s read-only directly with a self-contained prompt.
  • Claude models (sonnet-5, opus-4.8, fable-5) run via the Agent/Workflow model parameter.

Using gpt-5.5 inside workflows and subagents (the model parameter only takes Claude models, so use a wrapper):

  • Spawn a thin Claude wrapper agent with model: 'sonnet', effort: 'low' whose prompt instructs it to write a self-contained codex prompt, run codex exec via Bash, and return [the result]

Why this is the keeper artifact-shape: it's not a rule list, it's a scored capability matrix + tie-break order + standing escalation permission. Post-cutoff you delete the fable-5 row (or reprice its cost to 1) and the doctrine still routes. The three transferable inventions: (1) the cost/intelligence/taste axes with "taste >= 7 for anything user-facing", (2) "Judge the output, not the price tag. Escalating costs less than shipping mediocre work" — standing permission to re-run on a smarter model without asking, (3) the tie-break order "intelligence > taste > cost" for anything that ships. ADAPTATION NOTE: This user's fleet doctrine (GLM=UI, Codex=review/rescue, Fugu=vision) maps directly onto a taste/intelligence/cost matrix — tonight's CLAUDE.md rewrite should convert the prose fleet rules into theo's table shape, scored for HIS fleet, with Fable's row retained but cost-scored ~1 (credit era) so the doctrine survives the cutoff without edits.

The distilled consensus (across all sources this sweep + prior)

  1. Opus 4.8 inherits the orchestrator/review seat; Sonnet 5 is the default executor; a cheap non-Anthropic peer (GPT-5.5/Codex) takes bulk mechanical work. (theo, BHolmesDev, diegocabezas01, robbieleffel: "use Fable as designer/planner/facilitator and have Codex do all the implementation.")
  2. Effort dials matter more than model swaps at the margin: kaize — "Effort on high by default: xhigh only for genuinely brutal runs — high on Fable often beats xhigh on older models" (post-cutoff: same logic, one tier down — Opus high default). 0xclayn (prior sweep): Fable at LOW effort still beat Opus 4.8 at max on DeepSWE — i.e., effort settings don't rescue the cheaper model on genuinely hard tasks; route those UP a model, not up an effort tier.
  3. The parallel-adjudication pattern for high-stakes calls survives the cutoff: task Opus + Codex on the same problem independently, synthesize without cross-contamination (diegocabezas01, 5k likes).

FAILURE ARCHAEOLOGY / CORPUS-DRIVEN SKILL GENERATION (hunt #4 — thin but real)

The published state of the art is thinner than hoped. What exists:

  1. kaize's "audit your repetitive work" move (@0x_kaize, Jul 6, x.com/i/status/2074205915431973130): "Feed it your chat history and the prompts you keep rewriting. Everyone has 5-10 tasks they re-explain from scratch every week, but Fable 5 turns each one into a skill. One deep session today = tokens you don't pay $50/M for next week." — the only explicit transcript-corpus→skills prompt found.
  2. Voicu's failure-archaeology taxonomy category (Playbook #1): "chronicle of major investigations, dead ends, rejected fixes, reverts as symptom -> root cause -> evidence -> status. Frame the description so it loads during debugging, or it will never trigger. Mine git history hard." — corpus = git history, not transcripts.
  3. EXM's extract-approach recorder (Playbook #6) — prospective, not retrospective.
  4. Nobody found publicly mining ~/.claude/projects/**/*.jsonl at scale for skills. This user is ahead of the field here: Mission Control already computes dead-skill/cache/doctrine/mismatch audits over the 5.3k-session corpus. ADAPTATION NOTE (the synthesized play): don't feed Fable raw transcripts (token suicide at $10/M-equivalent quota). Feed it Mission Control's AUDIT OUTPUTS + the Dreaming Ledger lessons + the feedback_*.md memory files (already-distilled failure stories) and ask for Voicu-format failure-archaeology skills: symptom -> root cause -> evidence -> status, with descriptions framed to fire during debugging. The feedback memory corpus (boil-the-ocean, dont-give-up, diagnose-dont-workaround, scrape-and-record-first, verify-live-not-dryrun…) is literally "the failure stories that cost real time" already written — Fable's job is only to convert them into trigger-rich SKILL.md form for Opus/Sonnet.

QUOTA STRATEGY FOR THE FINAL WINDOW (hunt #6)

  1. Two-stage rubric prep (cheap model preps, Fable runs once) — u/iamjohncarterofmars (604 pts, r/ClaudeAI 1ukaogz): Opus scans the repo locally + a deep-research audit rubric, "sanitizes the instructions so Fable 5 can run a highly targeted, non-destructive audit… This intermediate step ensures Fable receives a project-safe rubric tailored exactly to your architecture without wasting your limited Fable 5 quota." (His Opus prompt begins: "I am providing a deep research report containing a code audit rubric. I plan to pass this rubric to Claude Code running Fable 5 to execute an autonomous audit on…" — full text truncated in API; shape is complete.) Matches the user's existing "tune prompts on Sonnet first" doctrine.
  2. The inversion: Opus main loop, Fable pinned in subagents — u/Old_Garlic6956 (51 pts, same thread): "Tell Opus 4.8 to spawn fable agents to audit the entire project… When the results come back to Opus you then ask it to plan out what work it will do… Saves a ton of tokens and you dont get model switched." Two wins: the per-turn context-resend tax lands at Opus rates (the "$20 hey" mechanic), and classifier fallback can't hijack the main session.
  3. Effort discipline — kaize: "Effort on high by default: xhigh only for genuinely brutal runs." Hierarchy-planner: "BUDGET_MODEL at low effort for extraction is almost always correct."
  4. Fan-out caps as HOOKS not prose — hierarchy-planner (Playbook #7); the 96-agent review disaster (prior sweep) is the failure mode; EXM's "cap every run: turns or wall-clock… one unattended loop without a cap billed $6,000 by morning."
  5. One big brief, fresh sessions, lean context — kaize: "No drip-feeding 20 messages, only full context and constraints in message one." mardehaym: "Start fresh sessions often. Keep your context lean."
  6. Burn math — EXM: "fable burns weekly limits roughly twice as fast as opus, and only half your weekly limit applies to it." Field cost datapoints: tomicz-shape run ≈30% weekly (one report: 60% and unfinished); overnight tiered-workflow run $20 vs $300-400 unrouted; cjzafir 17h Fable(high)-orchestrator × GPT-5.5(xhigh)-executor goal run = 27% Fable / 54% Codex weekly, "Fable not just created plans but built skills to elevate GPT 5.5 and now GPT 5.5 is at least 2x better than base."
  7. What burns quota fastest (avoid): blind parallel skill-authoring agents (duplicate facts, Voicu), one-agent-per-search-result research fan-outs ("can burn 100k+ tokens on a simple query" — Playbook #7), security-phrased subagents (classifier fallback wastes the run), long-session "hey" messages, and re-running a tripped classifier prompt in the same chat ("Rephrase neutrally, or open a fresh chat" — prior sweep).
  8. pxpipe-like compression: NULL — nobody else found doing context→image compression for Fable runs; the user's pxpipe remains ahead of the field. (Closest: a r/ClaudeWorkflows "Token Slayer" skill for pasted-content compression, 67% reduction claim, and stale-CLAUDE.md pruning below.)

SKILL-HYGIENE CONFIRMATIONS (hunt #5 — beyond Playbook #3)

  • Stale-instruction pruning validated independently (r/ClaudeCode via r/ClaudeWorkflows 1thc6aq, source comment omljphs on 1th04si): CLAUDE.md+skills are processed every turn; "161 to 52 collapse is real" [session limit improvement], "a third of those bytes are stale instructions", "compounds into six figures of pure waste you never see in any meter." Method: line-by-line audit, delete stale/ignored/contradictory lines.
  • Auto-invocation reliability: the consistent advice across Voicu + aiedge card: the DESCRIPTION is the trigger surface — trigger-rich phrasing ("exactly when to load it"), state what it's NOT for, name the sibling skill, and never park archival/always-on content in skills (it can never fire). No hook-based skill-forcing hack found this sweep.
  • The mod-bot workflow library independently canonized the Voicu/tomicz lineage as "Workflow value: 95/100" (r/ClaudeWorkflows 1ul5lxs, source comment ov17362 on r/ClaudeAI 1ukynrw "Friendly reminder to have Fable 5 write skills…") — same 3-phase structure; validation signal: "After fable did a fantastic job of it, I asked it to write a generalized prompt."

VERBATIM QUOTES

  • "Treat intelligence as borrowed. Drain intelligence when it's available. Build a catalog of plans today. Then implement later with a cheaper, open source, or a model you control. Build the backlog now." — @shadcn, Jun 13 2026
  • "The plan is the product." — shadcn/improve README
  • "Judge the output, not the price tag. Escalating costs less than shipping mediocre work." — @theo's CLAUDE.md, Jul 2 2026
  • "I was throwing away ~50% of my end-to-end agent-driven PRs before building this workflow. I haven't had to close a single one today :)" — @theo, Jul 2 2026
  • "can a cheaper model redo this tomorrow? … the teacher is dead, everything trained on it still runs" — @EXM7777 article, Jul 6 2026
  • "a cheaper model can't invent a quality bar, but it applies a written one fine" — @EXM7777 article
  • "tomorrow opus doesn't need to be brilliant, it needs to follow a brilliant document" — @EXM7777 article
  • "A cheaper model can't invent a high-quality standard, but it's highly efficient at following a pre-written one… you're leaving 90% of the value on the table." — @EugeniusOnlineC reply, Jul 6 2026
  • "Give a model a count and it pads to hit it, and the padding is where invented commands come from." — @VoicuDragomir, Jul 5 2026
  • "A model verifies only if it runs the thing… Without that step the review is theater." — @VoicuDragomir
  • "Skills load on demand when a task matches the description… release history and 'external positioning' never get triggered by anything and just sit there dead." — @VoicuDragomir
  • "Implement guardrails as hooks, never as prompt instructions. Prompt instructions fail under context pressure. Hook enforcement does not." — u/Rabello_quo, Jul 4 2026
  • "the architect must pass a Definition of Ready before routing, or a cheaper worker will confidently wander down the wrong path" — u/sideshowwallaby, Jul 6 2026
  • "Fable is the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns." — @trq212 (Anthropic), Jul 3 2026
  • "Every explainer, brainstorm, interview, prototype, and reference is a cheap way to find out what you didn't know before it gets expensive to fix." — @trq212
  • "I have to explicitly ask it to dumb down whatever skills it's writing for other agents that are not fable or GPT 5.5." — @GMASMROfficial, Jul 5 2026
  • "make Fable write the tests and failure cases for those replacement skills too. Otherwise you keep the style of its judgment, but lose the acceptance surface that tells the next model when it is wrong." — @UncleJAI, Jul 6 2026
  • "Saves a ton of tokens and you dont get model switched." — u/Old_Garlic6956 (Opus-spawns-Fable inversion)
  • "one unattended loop without a cap billed $6,000 by morning" — @EXM7777 article
  • "Silent upward routing from Sonnet to Fable, with the UI still claiming Sonnet, is documented nowhere." — u/tandembicyclegang, Jul 5 2026 (claude-code#74245)

NULLS / SKIPPED (honest)

  • No public transcript-corpus (.jsonl) mining playbook exists. kaize's "feed it your chat history" one-liner is the entire published state of the art. The user's Mission Control audit pipeline is ahead of anything found.
  • Exact prompt texts trapped in images: EXM7777's 5 paste-ready prompts (article embeds), PrajwalTomar's "comment 1" full prompt (image; but the tomicz GitHub repo tomicz/fable-5-train-opus-skills-after-it-retires is the canonical text, already in hand, and Voicu's rewrite supersedes it), iamjohncarterofmars's full Opus-vetting prompt (truncated mid-text in the API; Perplexity link perplexity.ai/computer/a/97317781-4c97-4de0-88e9-e7c28186c99 not fetched — auth-gated surface).
  • No before/after CLAUDE.md diffs found — people share doctrine sections (theo) and rewrite CLAUDE.md privately; nobody published a genuine before/after.
  • kaize's "Loop engineering" article (his most token-hungry workflow, recommended as post-extraction burn) not fetched — linked as an X article behind another hop; likely low marginal value vs. the /goal machinery the user already has.
  • Skipped: EXM's "25 INSANE loops" screenshot pack (listicle, screenshots-only), @_MaxBlade's CNVS app plug, jailbreak content (@VittoStack), the r/ClaudeAI RFC for a cross-user "skill mesh" (score 5, vaporware), AISEOInsider subreddit spam, Japanese amplifications (no new mechanics).
  • Reddit read on comment permalinks returns nested replies as "[+N more replies]" stubs — deep comment chains (e.g. the exact 1ukynrw ov17362 original text) not fully expandable via this backend; mitigated because the mod-bot workflow post preserved the full structure.

TOP-3 TO RUN TONIGHT (ranked for THIS setup, ~34h left)

  1. Skill-catalog triage first (Playbook #3 + Voicu Phase 2), it's the cheapest-per-value: feed Fable the 110 skill DESCRIPTIONS + Mission Control's dead-skill audit; get per-skill verdict (keep/merge/CLAUDE.md/docs/delete) + rewritten trigger-rich descriptions + conflict list. Bodies only for keepers that fail clarity/edge-case checks. This directly attacks the 95-never-fired problem and shrinks every future session's token tax.
  2. CLAUDE.md rewrite into theo's matrix shape + the missing doctrine lines (Playbooks #2/#7/#8): convert fleet prose into a scored cost/intelligence/taste table (Fable row repriced, not deleted), add: standing escalation permission ("judge the output, not the price tag"), intelligence>taste>cost tie-break, Definition-of-Ready handoff gate + RUN-STATE.md run log, parallel Opus+Codex adjudication for high-stakes calls, EXM's two /goal safety rules (pasted proof + hard caps), and move the subagent-cap from prose to a hook.
  3. Per-repo plan-backlog drain (Playbook #1b): install shadcn/improve, run /improve on rally + foreman + mission-control under Fable, bank plans/ (self-contained, verification-gated, STOP-conditioned specs). Post-cutoff Sonnet/GLM executes them. If quota allows, run the Voicu extraction prompt on ONE repo (mission-control), seeded with the audit outputs, capped orchestration.

Then, if hours remain: install the extract-approach recorder rule + fold trq212's unknowns patterns into fable-judgment (near-zero quota), and let a capped /goal run drain the rest on the highest-value backlog item.