最近摸索了一种新的节约 Token 但是效果不错的模式（都是被逼的，Token 太贵）：

Fable 写设计方案 -> 
（Loop 开始）
Opus 执行 -> Advisor（Fable） 验收
（Loop 结束）

步骤是这样的：

1. 先 Claude 里面设置一下 advisor 为 Fable
> /advisor fable

这样在使用 Opus，Sonnet 模型的时候，遇事不决它会请教 Fable，可能会有无谓的 Fable 消耗，但还是可以接受也值得

就好比请了个高级工程师当顾问

2. 复杂一点的问题先让 Fable 出方案，最大化利用 Fable 的能力。

就好比你让一个高级工程师写一个技术方案，让普通工程师去执行

3. 方案写好了确认了，让 Opus 去执行，但是执行的时候，加一句提示词：

> 完成后让你的 advisor 验收一下，如果验收有问题就按 advisor 的反馈修复，修复完成后再让 advisor 验收，直到通过 advisor 的验收为止

可以配合 /goal 使用效果更佳

这样 Opus 在实施完成后就会找 Advisor 验收，通过 Advisor 就会给出反馈，然后 Opus 继续修改。

这样的好处就是整个过程你不需要人工去用 Fable 确认—— 以前我就是这么干的，Opus 执行完，我得回到之前 Fable 的会话去让它验收，或者新开一个会话，把文档发给 Fable 验收。

现在 Agent 自己就能形成闭环，不用你自己参与。

就好比你请了个高级顾问，复杂问题找顾问出方案，执行让你的工程师去按照方案执行，每次工程师做完自己去找顾问验收，顾问不仅验收还会告诉工程师哪里不对，然后工程师自己改，不用说每次做完找你，你再找顾问。

holy sh*t. Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Haiku 5.5 can swarm, while Sonnet 5.5 builds

put the architect on call with /advisor

claude --advisor opus --subagents haiku

Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites
Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, handling file discovery and spec docs lookup
Opus 5.5 stays on call in the background as the advisor, only stepping in at three critical moments:

→ before a plan locks: does the implementation plan miss auth invariants or schema contracts?
→ when a test breaks twice: are we fixing the root cause or falling into a recursive rabbit hole?
→ before calling done: did the full diff introduce hidden regressions or break pre-flight rules?

Opus 5.5 reviews. Sonnet 5.5 builds. Haiku 5.5 swarms

Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) execute in 16ms, so the frontier models only wake up when execution paths actually diverge

Plan on high. Delegate on medium. Keep Opus on call.

- the full advisor setup
> Opus 5.5 on call reads full session history and catches deep architectural traps
> Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses
> Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel
> JEV micro-fork layer resolves 1,500+ mechanical routing branches in under 16ms
> advisor stays completely silent on routine bash execution to protect context

paste the setup and this prompt into Claude Code below:

"Configure my Claude Code workspace for hierarchical advisor orchestration:

1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and advisor:
> Pin main session model: sonnet with effortLevel: high for primary execution
> Pin subagents model: haiku with effortLevel: medium for parallel file discovery and docs retrieval
> Pin advisor model: opus on call for strategic review

2. Enable the advisor tool in ~/.claude/settings.json:
> Set advisorModel to claude-opus-5-5
> Enable subagent parallel dispatcher pool (3x workers)

3. Configure automatic advisor consultation checkpoints in ~/.claude/CLAUDE.md:
> Consult /advisor opus before finalizing multi-file architecture plans
> Automatically summon /advisor opus when the same test or compiler error fails twice
> Enforce advisor diff contract audit before declaring tasks complete or staging git commits

4. Constrain subagent scopes:
> Haiku subagents return structured AST summaries and docs snippets only without modifying main session context

Show every configuration diff first. Do not apply edits until confirmed"

↳
https://t.co/gvAWk6KbDn

Anthropic just published its 𝗳𝘂𝗹𝗹 𝗰𝗼𝘀𝘁 𝗴𝘂𝗶𝗱𝗲 for Opus 5.5. You can ask Opus 5.5 to use it to review your Claude Code setup.

At the same effort level, Opus 5.5 thinks more per turn than Opus 5, most of all at xhigh and max. Thinking is billed as output, and an output token costs 𝟭𝟬𝟬 𝘁𝗶𝗺𝗲𝘀 𝗮 𝗰𝗮𝗰𝗵𝗲 𝗿𝗲𝗮𝗱. So don't carry over the level you set for Opus 5. Start at medium, and save xhigh and max for work where you've measured a gain.

Send this prompt to Opus 5.5 👇

"Read this guide: https://t.co/8RHkfmiKjM

Then review my Claude Code setup against it: my user and project settings, the subagents in ~/.claude/agents and .claude/agents, CLAUDE.md, and the MCP servers I have connected. Find three kinds of problems:
1. A default effort that doesn't fit the work. Use the guide's ladder: low for mechanical edits, medium for well-scoped daily work, high when medium stalls, and xhigh or max only for work where a gain was measured. Flag a default of xhigh or max, or a level I picked for Opus 5. Then look at this project's code and recent commits and tell me which kinds of work here fit which level.
2. Subagents that only search, read logs or run tests but set no model, so they run on my main model.
3. Setup that makes every turn cost more: MCP servers I don't use, or a CLAUDE.md well over 200 lines.

For each issue, quote the setting or line, explain what it costs, and suggest the smallest change. Also tell me which three things to check in /usage at the end of a task.

Show me the recommendations first. Don't change anything yet."

Here's a step-by-step process to kill all the bloat from your Claude Code system prompt:

1. Run a proxy so you can see exactly what gets sent to Claude Code (included in the article)
2. "Fuck, there is so much cruft in there"
3. Use my settings.json to kill all the bloat

Down to a clean 13K tokens to start each session with. Nice.

Full process here:

https://t.co/Kie84HMe2A