如何低成本使用Claude Fable 5

Fable 5 是我用过的最好的 AI 模型。

但它也贵得离谱。

在最初几个小时的测试中，我几乎用完了全部使用额度。

而且我甚至没做什么疯狂的事。

Fable 的价格是 Opus 4.8 的两倍。

而且因为它太聪明了，它会过度思考——以以往任何 Claude 模型都没有的方式运行循环、消耗 Token。

大多数人使用它的方式完全错了。

以下是我构建的、能将 Fable Token 成本降低 50% 以上的精确系统。

没有新工具。输出量不变。只是更智能的路由。

每个人第一天都会犯的错误

你打开 Claude Code。

Fable 现在是默认模型。

你开始聊天。

你让它修复一个错别字。你让它格式化一些 JSON。你让它重命名一个变量。

Fable 思考了 12 秒，消耗了 8,000 个推理 Token，返回了答案。

成本：0.60 美元，完成了一个 Haiku 只需 0.02 美元就能搞定的任务。

你支付着外科医生的费用，却只进行闲聊。

Fable 是一位架构师。

不是一个室友。

当你内化这一点时，一切都会改变。

10-80-10 系统（Anthropic 工程师自己使用的精确框架）

每个 Fable 项目都有三个阶段。

大多数人在 Fable 上运行所有三个阶段。

明智的做法是只在 Fable 上运行其中两个。

最初的 10% —— 规划

这是 Fable 值回票价的地方。

在任何项目开始前，使用 Fable 来定义：

→ 结构和方案 → 成功标准 → 约束条件和边缘情况 → 可能出错的地方

想象一下建造一所房子。

最昂贵的错误是给建筑工人一张糟糕的蓝图。

先把架构搞对。

Fable 在这方面非常出色。

中间的 80% —— 执行

这是消耗最多 Token 的地方。

来回沟通、迭代、实现循环、实际完成任务所需的繁重工作。

Fable 不需要参与这个阶段。

标准工作切换到 Opus 4.8，简单任务用 Haiku，机械性执行用 Codex 或 GPT-5.5。

你获得了 Fable 级别的架构，而无需为每一个执行的 Token 支付 Fable 的价格。

最后的 10% —— 审查

让 Fable 重新介入。

让它根据原始计划审查输出：

→ 结果是否符合架构？ → 是否有疏漏的差距或边缘情况？ → 在发布前是否有需要修复的地方？

因为 Fable 审查的是完成的输出，而不是从头生成，所以它消耗的 Token 只是它完成整个任务时的一小部分。

CLAUDE.md 路由表（控制一切的文件）

这是最大的突破。

在你的 CLAUDE.md 中维护一个路由表。

让 Fable 充当协调者，读取路由表并自动将任务分派给正确的模型。

以下是我使用的精确路由表：

## 模型路由表

### Fable 5（仅协调者）
使用场景：规划、架构、审查最终输出
绝不用于：机械性任务、批量生成、样板代码
努力级别：高（绝不用极高——它是输出更差的 Token 燃烧器）

### Opus 4.8（深度推理执行者）
使用场景：复杂调试、多步推理、任何需要真正思考但
        不是架构设计的事情
成本层级：标准

### Sonnet 5（机械工作执行者）
使用场景：代码生成、重构、标准功能开发
成本层级：便宜

### Codex / GPT-5.5（同行执行者）
使用场景：实现任务、UI/UX 验证、规范明确的工作
注意：Fable 可以学习引导 Codex —— 教一次即可
成本层级：通常在 Codex 计划下免费

### Haiku（批量执行者）
使用场景：格式化、lint、简单编辑、样板代码、重命名重构、
        测试脚手架
绝不从 Haiku 派生进一步的子代理
成本层级：最便宜

### Kimi / GLM-5.2（长上下文执行者）
使用场景：读取大型文件、长期代码库分析，以便
        Fable 不必为此消耗 Token
成本层级：非常便宜

### DeepSeek / Qwen（极其便宜的苦力工作）
使用场景：样板代码、编写测试、数据清洗、翻译、
        文档初稿、批量生成
成本层级：近乎免费

Fable 从不直接接触便宜的工作。

它进行规划，委派给正确的层级，然后根据计划检查结果。

昂贵的大脑只消耗用于决策的 Token。

就是这个文件，让我的支出下降了，而产出却上升了。

为我节省了 70% Token 的精确 CLAUDE.md 设置

以下是我添加到 CLAUDE.md 中的完整编排部分：

## 编排工作流

你（Fable）是协调者。负责规划、分解、综合。
不要自己执行机械性任务。

### 委派规则：
- 推理密集型阶段 → deep-reasoner（Opus 4.8）
- 机械性工作 → fast-worker（Sonnet/Haiku）
- 代码库分析 / 大型文件 → Kimi（长上下文）
- 样板代码 / 批量任务 → DeepSeek 或 Qwen
- 来自不同视角的同行评审 → Codex

### Codex 是同行，不是评审者：
将 Codex 视为来自不同视角的、能力超群的高级工程师。
对于高风险决策：在同一个问题上并行安排 Opus + Codex，
综合两者的最佳结果，且不让任何一方看到另一方的答案。

### 上下文纪律：
保持你自己的上下文精简。
永远不要重新读取你已经处理过的文件。
在将工具输出反馈到上下文之前，先进行总结。
要求模型返回简洁的结论，以便你采取行动。

### 努力级别：
- 规划和架构：高努力
- 审查轮次：中努力
- 永远不要默认使用极高/最大——成本更高，输出通常更差

现在像技术主管一样提示 Fable：

目标：[你想要什么]
上下文：[文件、约束条件、你担心的事情]

你是主管。
将推理委派给深度推理者（Opus）。
将苦力工作委派给快速工作者（Sonnet/Haiku）。
对于需要新鲜视角的问题，使用 Codex。

先向我展示你的计划，然后执行。

就是这样。

Fable 规划。其他一切执行。账单保持稳定。

安装 Codex 插件 —— 倍增器操作

这是大多数人跳过的一步。

Codex + Fable 结合使用，效果是单独使用 Fable 的 10 倍。

Fable 做架构。Codex 以 GPT-5.5 的质量执行。你几乎不触碰你的 Claude 限制。

设置只需不到 5 分钟：

步骤 1：在你的机器上安装 Codex CLI

npm install -g @openai/codex

步骤 2：在 Claude Code 中添加插件

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/codex:setup

步骤 3：在 Claude Code 中创建两个子代理

/agents

→ deep-reasoner
  模型: Opus 4.8
  指令: "用于推理密集型阶段、架构、调试复杂问题。
         思考透彻，返回一个协调者可操作的简洁结论。"

→ fast-worker
  模型: Sonnet 5
  指令: "用于机械性任务、样板代码、测试、格式化、
         简单编辑。高效执行。"

步骤 4：让 Fable 为 Codex 编写一个 SKILL.md 文件

编写一个 SKILL.md 文件，精确指导 Codex 如何：
- 阅读并执行实现计划
- 运行测试并向你报告结果
- 处理此项目中特定的文件结构

确保 Codex 在机械性工作上不需要任何手把手的指导。

Fable 只需编写一次技能文件。

Codex 在未来的每次运行中都会读取它。

你的 Codex 输出会立即提升 10 倍。

/loop 命令（目前使用 Fable 最强大的方式）

大多数人仍然使用旧的方式提示。

你发出提示 → Fable 响应 → 你审查 → 你再次提示 → 重复。

在这种模式下，你就是循环本身。

你手动验证每一步、每一次修正、每一次跟进。

循环将你从瓶颈中解放出来。

它是如何工作的：

你预先向 Fable 提供一个目标。

它会启动子代理来朝着这个目标工作。

代理们自行提示，并在完成后向你报告。

两个命令：

/goal — 定义任务和最终状态

结构：
/goal [任务] until [可衡量的最终状态] without [约束条件]

示例：
/goal 重构认证模块 until 所有 47 个测试通过
without 触及支付服务或数据库架构

/loop — 按计划自动运行一个提示

结构：
/loop [你的提示] --interval 30m --expires 8h

示例：
/loop 在所有 API 端点上运行安全检查
--interval 24h --expires 7d

组合使用：

/goal 重建仪表板组件 until Lighthouse 分数在移动端超过 90
without 破坏现有测试

/loop run /goal above --interval 6h --expires 48h

Fable 设计循环。更便宜的模型在循环内部执行那 80% 的工作。只有当循环结束或遇到阻碍时，Fable 才会回来介入。

你醒来时，任务已经完成了。

现在在 Fable 上运行的 7 个提示

这些是在将 Fable 用于其他任何事情之前，最高杠杆的使用方式。

不是为了氛围编码。

不是为了发布功能。

而是打磨你已经拥有的每一个系统。

1. 找出哪些任务真正值得在 Fable 上运行

你是 Fable 5，目前最强大的模型。

浏览我的项目、文档和记忆。

列出最值得在你身上运行的 5 大任务。

每个任务用一行理由说明其排名。

现在不要做具体工作。

2. 在构建任何东西之前，重新设计你的构建方式

我希望你完全审计并重新设计我的编码工作流。

这是我当前的工作方式：[描述你的流程]

我的目标是：[你想要交付什么]

审查、审计、优化并改进我的系统。

不要写代码。在我们运行工厂之前，先重新设计它。

3. 规划大型项目 —— 现在不要构建它

我想规划：[描述项目]

现在不要构建。

列出完整的计划：阶段、关键决策、风险、未解决问题。

标记任何可能导致项目失败的因素。

使计划足够清晰，让 Sonnet 或 Codex 能够
逐步执行，而无需向我提问。

4. 在发布前，找出所有问题

我即将发布这个项目。

在发布前，先找出它所有的错误。

通读整个代码库。

寻找真正的 Bug、有问题的边缘情况，以及任何
会在用户面前出问题的事情。

列出每个问题并附上：复现步骤和修复方法。

设置高标准。要毫不留情。

5. 从头重写你的 CLAUDE.md

阅读我当前的 CLAUDE.md。

它是为旧模型编写的，并且过于臃肿。

更短、更清晰的指令在 Fable 中表现更好，成本也更低。

重写它：
- 移除 Fable 不再需要的指令
- 精简每个工作流
- 从我们的对话中添加模型路由表
- 尽可能将每个部分控制在 5 行以内

Fable 会自己搞定剩下的部分。

6. 获取它已知关于你一切的业务建议

你是我的业务顾问。

阅读我的计划文档、已连接的工具和记忆。

为我的业务写一页评估报告，内容包括：
- 未来 3 个月最重要的 3 件事
- 应该放弃什么及原因
- 一件我可能没有意识到的事情

7. 自动化的安全扫描

/loop 对我所有的 API 端点运行安全检查。

寻找：暴露的密钥、缺失的身份验证、速率限制漏洞、
注入向量，以及任何恶意用户可能滥用的东西。

仅报告真实问题，并附上严重性评级。

--interval 24h --expires 7d

努力级别 —— 最容易被误解的设置

大多数人默认使用最大或极高。

这是错误的。

以下是每个级别实际发生的情况：

• 低：快速、便宜，对于简单任务出奇地好用。许多人报告在这里有惊艳的输出。
• 中：最佳平衡点。中努力级别的 Fable 击败极高努力级别的 Opus。默认使用这个。
• 高：用于困难的调试、多文件重构、架构决策。真正的推理能力。
• 极高 / 最大：Token 燃烧器。通常产生的输出比“高”级别更差。只为你面对过的真正最困难的问题保留。

规则：从中级别开始。只有在质量确实不达标时才升到高级别。永远不要默认使用最大。

还有一个会扼杀预算的设置：

扩展思维 —— 默认关闭。

仅对真正需要它的问题开启。永久开启它就像让引擎在车道上一直空转。

/handoff 技巧 —— 解决上下文窗口膨胀问题

长时间会话是隐形杀手。

每一次轮换都会重新发送完整的对话历史。

一个 200k Token 的会话会成为你账单上最昂贵的东西。

修复方法：频繁开启新聊天。

但你不希望在这样做时丢失上下文。

使用 /handoff 技能：

给我一个提示，我可以用它在一个新的聊天中重启此会话，
而不会丢失我们任何上下文。

包括：
- 我们决定了什么
- 我们构建了什么
- 接下来的步骤
- 我必须记住的任何重要约束条件

使其小于 500 Token，以便新会话开始时保持精简。

复制该输出。

打开新聊天。

粘贴它。

以一小部分的上下文成本，从你离开的地方精确继续。

每 30 到 60 分钟开启一次新的会话 = 大量节省 Token。

要避免的 4 个昂贵错误

错误 1：Fable 现在是默认模型。

当你打开 Claude Code 时，它会自动使用 Fable。

在每次会话前检查模型选择器。

这个习惯已经防止了我在普通聊天中意外运行 Fable 很多次，多到我不愿承认。

错误 2：没有支出上限。

在 7 月 7 日，Fable 将移出标准订阅。

立即添加信用卡并设置一个硬性的月度上限。

设置 → 用量 → 调整限制。

Fable 在自主运行和长时间会话中会快速消耗 Token。

没有硬性上限，一次夜间代理运行就可能在你醒来前产生一笔账单。

已经有人因为一个提示被收取了 960 美元。

今晚就设置上限。

错误 3：要求它解释其推理过程。

那一个请求可能会触发分类器，你的工作会悄悄地交给一个较弱的模型处理，而你却还以为自己仍在用 Fable。

跳过“为什么”这类请求。判断输出质量，而不是过程。

错误 4：一点一点地向它喂小提示。

Fable 可以在其头脑中保存数小时的上下文。

一次性给它完整、凌乱的内容。

完整的上下文。约束条件。你真正害怕的东西。

我把一个我几周来一直害怕的重构任务，用一条简洁的消息交给了 Fable。它回来时已经完成了。

一点一点地喂会浪费它最擅长的一个能力。

模型成本对比 —— 了解你实际在支付什么

在你路由任何任务之前，了解每个模型的价格：

模型              输入 ($/M)   输出 ($/M)   最适合
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Fable 5            ~$15         ~$75         规划，审查
Opus 4.8           ~$5          ~$25         深度推理
Sonnet 5           ~$3          ~$15         标准执行
Kimi K2.7          ~$0.95       ~$4.00       批量编码，长上下文
GLM-5.2            ~$1.40       ~$4.40       代码库级工作
DeepSeek v4        ~$0.28       ~$1.10       极其便宜的苦力工作
Haiku 4.5          ~$1          ~$5          清理，格式化
本地 (Qwen/Llama)  $0           $0           自动完成，样板代码
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Fable 和 DeepSeek 之间的差距：输入方面 53 倍，输出方面 68 倍。

同样的 30 步重构代理：

• 全部使用 Fable：每次运行约 25 美元
• Fable 规划 + Kimi 执行：每次运行约 1.40 美元
• 相同的代码发布，相同的测试通过。

路由不是为了省钱。

而是为了精准。

完整系统 —— 运行时的样子

使用此系统前：

• 所有内容都路由到 Fable
• 每次发布，账单都会飙升
• 使用限制在会话中途达到上限
• 你像精打细算的旅行者一样定量使用提示

使用此系统后：

• Fable 处理那 10% 真正需要它的工作
• 廉价模型处理那 80% 的执行工作
• /loop 在夜间运行，不影响你的限制
• 你交付更多，花费更少，从未达到速率限制

三行总结：

Fable 规划。其他模型执行。Fable 审查。

在你改变任何其他东西之前，这一个规则就能让你的账单降低 50% 以上。

其余的都是优化。

今晚就运行这个

立即将其放入 Fable：

阅读我当前的 CLAUDE.md 和我所有活跃的项目。

你的工作：为我的工作流设置 10-80-10 路由系统。

创建：
1. 包含完整模型路由表的更新版 CLAUDE.md
2. 我当前活跃任务的列表，按每个任务应由
   哪个模型处理来排序
3. 三个我今晚可以在更便宜的模型上运行的 /goal 提示，
   基于你在我的项目中看到的内容

不要执行任何东西。只需规划和路由。

Fable 做规划。

你醒来时拥有一个完整的路由系统。

以及一份不会让你心脏病发作的账单。

• 原文链接： x.com/sairahul1/status/2...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～