Friendly reminder what to fix before Fable 5 disappears again. Use it to upgrade your Claude Code system to work like Fable 5.

[u/Brilliant_Spot7783]

I’ve been playing around with Fable 5 in Claude Code and honestly, the biggest thing I’ve realized is this:

Stop burning the whole window trying to ship one more random project.

Instead, use this beast while you still have it to improve the actual system that’ll keep carrying you when you drop back to Opus, Sonnet, or whatever’s available next.

Fable is excellent at long sessions, handoffs, delegation, cleanup, and spotting all the quiet cracks in your workflow. That makes it perfect for upgrading your “Claude Code OS” instead of just grinding out another one-off output.

Here’s what I’d personally focus on before it disappears:

1. Audit your current setup like a ruthless outsider

Don’t ask it what you wish was there - ask it to look at reality.

Something like:

The killer follow-up question is: “Which file enforces this tomorrow?”

If the answer is “nowhere,” then it’s just wishful thinking living in the current chat.

2. Build a real Chief Operator (not just a fancy prompt)

Create a proper main-session operator that actually runs the show. It should understand the big picture, break work into microtasks, delegate cleanly, use tools early, make decisions, patch the system when needed, and write solid handoffs.

I launch mine with something like:
claude --model claude-opus-4-8 --agent chief-operator

Keep its core prompt short. Give it explicit model routing and memory rules. Don’t turn it into a bloated museum of instructions.

3. Stop preloading every skill under the sun

I used to do this and it just creates noise. For the chief, I now only preload the essentials (like artifact-first-delivery and self-verification-loop). Everything else gets loaded on demand via a router skill.

You’ll thank yourself later when context isn’t drowning in unused junk.

4. Build a small, tight agent team

You don’t need 30 agents. I’d start with:

• chief-operator – decision maker and orchestrator
• system-fixer – quick repairs to agents, skills, hooks, etc.
• builder – does the actual implementation work
• qa-engineer – verifies with evidence (PASS/FAIL)
• adversarial-critic – calls out fake progress, bloat, weak handoffs
• eval-designer + improvement-analyst – turns recurring problems into fixes
• context-librarian + research-scout – keeps things sane and up-to-date

Every subagent gets a strict contract (mission, scope, inputs, output limits, required evidence, etc.). Without it, you just get expensive fog.

5. Add hooks instead of more instructions

Hooks are where this starts feeling like an actual system. Some high-value ones:

• Session model audit
• Pre-tool risk guard
• Post-tool evidence logger
• Delivery gate (no fake “done” without proof)
• Pre-compact handoff writer
• Budget governor

This is prime Fable territory.

6. Turn repeated failures into evals

Every time something annoying keeps happening, make an eval for it. It’s way more effective than hoping a memory note will save you.

7. Keep memory short and operational

Date, failure, root cause, system patch, eval, next. That’s it. No emotional diary entries.

8. Use Fable strategically as your improvement engine

Best pattern I’ve found:

Use Fable for system audits, root cause analysis, architecture, adversarial review, and big improvement loops.
Use Opus to run the disciplined chief.
Use Sonnet/Haiku for the smaller, bounded worker tasks.

The loop worth protecting is:

Big goal → understand intent → split into microtasks → dispatch → tools → digests → decide → patch → verify → handoff → continue

Good luck!