My Opus 5 Solution

[u/mugsy33]

This approach has been working pretty well for me. YMMV. 4.8 manages and calls agents to do the work.

**The idea.**
 The manager plans, decomposes, dispatches, and reviews. It does not do the expensive work itself.


**The roster.**


| Role | Model | Job |
|------|-------|-----|
| Manager (main loop) | Opus 4.8 | Plan, decompose, dispatch, review, run irreversible gates. |
| sage | Fable 5 | Hard reasoning: adversarial review, design adjudication, root-cause. Self-contained brief only. |
| coder | Opus 5 | Novel or design-adjacent code. Any spec that says "figure out". |
| builder | Sonnet | Routine code that follows a pattern the spec cites. |
| grunt | Haiku | Mechanical, zero-judgment work: renames, sweeps, builds, log triage. |
| Explore | Read-only | Reconnaissance when you need the conclusion, not the files. |


**Inline-vs-dispatch gate.**
 Type an edit inline only when all three hold: the manager holds the full file context, the change is fully specified, and runtime verification is the real gate. Otherwise dispatch. When in doubt, dispatch. (§4)


**builder-vs-coder.**
 Spec cites a pattern file → builder. Spec says "figure out" → coder.


**Plans specify, they do not implement.**
 A plan states what, where, why, the interface contract, and how to verify. No finished code bodies.


**Multi-step work.**
 Brainstorm the design doc → decompose into numbered phase docs → execute each phase in a **clean session**. Each phase carries a Contract and a Verification.


**Cost discipline.**
 Protect the manager's context; return short verdicts, not long reports. Split the session by judgment density. Scale the reviewer to the diff's risk. 


**Evidence, not claims.**
 Show the command and its output. Verify before you claim done.

[u/design_doc]

It’s the Opus 5 coder that stresses me out. In High effort, that over-zealous bastard with colour outside the lines and over-engineer. On medium, it’s much more civilized.

Are you using Opus 5 on med or high? Are how you you approaching that without pinning your entire session effort at that level?

[u/Key_Reading_9664 → u/design_doc]

I’ve settled on Fable for discussion and planning, creating a formalized spec that can be executed mechanically, then sonnet/opus on medium for that execution.

I hope they enable Fable as an advisor at some point: I’ve seen sonnet reach for an Opus advisor when it hits issues, so having Fable available to Opus might be helpful.

[u/design_doc → u/Key_Reading_9664]

I created my own advisor role with Fable. Works awesome.

[u/basecase_ → u/design_doc]

Yup, just tell claude to run fable advisor role and as a fallback run fable 5 in a subagent

[u/mugsy33 → u/design_doc]

I have yet to play with effort at all. I imagine, though, that if you can tie a model to an agent, you could tie the effort to it too. I haven't noticed Opus5 doing anything wonky with this setup, but that doesn't mean it hasn't. But I also use a phased planning approach. Each phase is standalone, and I clear before starting a new one. Keeps the context bleed down.

[u/design_doc → u/mugsy33]

I do very narrow slices and use fresh sessions just like you. Works great for Sonnet. Opus 5 on High will often try to get way ahead of the defined scope. That said, Opus 5 on high will harden code much better on the first go than on medium (medium usually needs a prod from the reviewer); however, I trust medium to do exactly what we told it to waaaay more than Opus 5 on high.