为什么你的 Claude Code 特别费 Token · 6 个高效对话技巧

高效对话与省钱第 3 / 7 篇

源视频：260824-1-为什么你的ClaudeCode特别费Token？6个高效对话技巧.mp4（19 分 14 秒，1280×720，画面水印「AI随风随风 / bilibili」） 整理方式：whisper large-v3-turbo 全片转录 + 145 张定点抽帧（每 8 秒）+ 66 张补抽（漏采段 30 + 按需 36）+ 逐点放大核对 本文所有 (mm:ss)：口播用转录串匹配定位，画面用 ffmpeg -ss 定点取帧（文件名即秒数），无一处凭印象

写作日期：2026-08-24｜复核：2026-09-07

📌 2026-09-07 复核（Claude Code 2.1.258）：本文推荐的斜杠命令里，10 个仍在、1 个查不到。

命令 复核
/compact /clear /context /model /effort /mcp /rename /doctor /autocompact /loop ✅ 全部仍在
/rewind 🚨 当前版本的斜杠命令清单和 claude --help 里都查不到

🚨 /rewind 这条要当心：正文第二节和第五节都把它当作「走偏了别急着 compact， 先试 /rewind」的推荐做法。实测在 2.1.258 上敲不出这个命令。 ⚠️ 但分不清是后来被移除还是本来就不存在 —— 它是整理时补充的 （正文自己写着「这条口播完全没提」），来源无从追溯。 ⇒ 照做前先跑下面的判据确认；查不到就退回 /compact，别在那儿反复试。

📌 正文第五节 /context 输出里那行 Skills · /skills 不是本文的推荐， 是视频画面的原样转录（而且那台机器的后端是 GLM-5.3，见该节的 🚩）。 当前版本同样没有 /skills 这个斜杠命令 —— 但它本来就不是让你敲的。

🔔 要重验就跑这一条（零成本，不产生模型调用）：

node experiments/agent-recheck/check-slash-commands.mjs \
  compact clear context model effort rewind mcp rename doctor autocompact loop

它读 headless 会话 init 事件里的 slash_commands 清单，读到就杀进程。 ⚠️ 脚本内置了双向校准：正例（/clear）必须命中、负例（编造的命令名）必须不中， 任一不满足就拒绝给结论 —— 只做负例校准挡不住「判据恒假」那种瞎法。

〇、先给结论：只想拿走能用的部分，看这 8 行

该改的习惯 怎么做 为什么
别让 Claude 自己找文件 用 @文件名 而不是描述文件 文件内容直接进第一条消息，省掉整条探索链，而探索链会被之后每一轮重发
开工前就把模型和 effort 定好 /model、/effort 都在会话第一句之前设 这两个都是缓存 key 的一部分，中途改会让整个会话按全价重新 prefill。官方 TL;DR 第 2 条专门点明 before you start，而图解页把这个要点拆散了（见第八节）
一个任务一个会话 做完就 /clear；想留着就先 /rename 长会话每一轮都在为全部历史买单
走偏了别急着 compact 先试 /rewind 只剪掉尾部几轮，前面的缓存照常命中，比 /compact 便宜
离开键盘前 compact 一次 /compact 想保留的说明 订阅模式缓存约 1 小时过期，趁热做摘要比过期后全价重来便宜
给吵闹的命令加安静参数 npm run -s test、git log --oneline、pytest -q；把常用命令连参数写进 CLAUDE.md 400 行「测试全绿」里有用的只有最后一行，但它们会留在上下文里被每轮重发
定期查谁在占上下文 /context、/mcp MCP / skills / agents 都是常驻开销，作者自己那台机器上光 skills + agents 就 17.2k tokens
脏活外包，但别滥用 日志分析、全量测试用子代理；小任务别用 每个子代理各付一份「系统提示 + 工具 + CLAUDE.md」，小活外包是净亏

⏱ 想更快的话：官方原文标注的阅读时间是 5 分钟（视频开头 00:02 的页面上就印着 Reading time 5 min）。这期视频用 19 分钟讲它，图解页又在原文之上加了不少内容 —— 如果你只要结论，直接读原文比看视频快。本文的价值在于第八节的核查和标注了「哪些是原文没有的」。

一、这期视频到底是什么

不是作者的原创方法论，而是逐段讲解 Anthropic 官方博客的一个自制图解页。

三层来源要分清（这一点视频里没有明说，但决定了你该怎么信这些内容）：

层 是什么 可信度
底层 Anthropic 官方博客 Maximizing the value of your Claude Code sessions，作者 Lydia Hallie，2026-08-14 发布 一手
中层 作者用 Claude Code 生成的本地图解页 claude-code-sessions-course/index.html，页脚自称「改编自官方博客，按原文顺序逐点图解」 二手改编，加了原文没有的数字（见第八节核查）
上层 作者对着这个页面口播讲解 三手，口播多处比页面粗糙

页面自己的标题是「降低 AI 编程成本：6 个必须掌握的上下文管理技巧」，副标题「原文逐点拆解 · 6 张流程图 · 新手向」，正文导语：

同样一个任务，换一种问法、换一种会话习惯，烧掉的 token 可能差出好几倍。先从一道选择题开始，再跟着原文的思路一层层抽丝剥茧，把每个 token 都花在刀刃上。

页面顶部常驻一条锚点导航（最左的「··· 省钱图解」是页头标识，其右 6 项是章节，也是全片骨架）：

··· 省钱图解 ｜ 开篇一问 · 成本组成 · ① 单价 · ② 数量 · ③ 排查 · 总结

二、开篇一问：三种问法，哪种最烧 token（00:20 – 02:00）

开场 20 秒他先开的是官方原文页（画面 00:02）：标题 Maximizing the value of your Claude Code sessions，副标题 How to run efficient sessions that get the most value from every token.，右栏三项元信息 —— August 14, 2026 / Reading time 5 min / Author(s) Lydia Hallie；页面上挂着划词翻译插件，每段英文下方浮着中文气泡（「最大化你的 Claude Code 会话价值」「如何运行高效会话，让每一个 token 都发挥最大价值。」）。看完这一屏他就切到自己的图解页，全片没有再回到原文。

同一个任务 —— 修复 utils.test.ts 里失败的测试，交给 Claude Code 做。页面让你先猜（每张卡下方有「揭晓答案」按钮，卡组右下角还有「↻ 重置（再猜一次）」），再逐张揭晓（画面 02:02 三卡全展开）：

「测试挂了，帮我看看」 「请修复 utils.test.ts」 「@utils.test.ts 修一下这个」
副标题 Claude 只能自己找 Claude 直奔目标 文件直接搭在你的消息上
过程 🔍 grep（按关键词搜代码）找测试文件
📄 打开 a.test.ts —— 不是它
📄 打开 b.test.ts —— 也不是
📄 读取 utils.ts —— 找到了！		 📄 Read utils.test.ts
📄 顺带读被测文件 utils.ts
⚒ 修复 + 跑测试		 🔗 首条消息已包含文件全文
⚒ 直接修复 + 跑测试
✅ 完成，零探索
代价 ≈ 4 次探索全部留在上下文里，之后每一轮都要把它们重发一遍 —— 账单越滚越大 说清了文件名，1~2 次读取直达目标，探索的痕迹少了很多 0 次额外读取 —— 文件内容在第一条请求里就到位了
结论 🐢 最贵 😐 适中 💰 最省

口播补充（00:55 提出问题，00:59 起逐个揭晓）：第一种「相当于模型要在你的仓库里自己去找一遍这个文件，那在寻找的过程中是需要消耗 token 的」。

页面在此处埋了全篇路线图：

只是换了个问法，成本就差出一截 —— 为什么？先看一次对话的成本怎么组成，再跟着原文逐个拆开：一个 token 的价格由什么决定（核心点①）→ 一个会话会发出多少 token（核心点②）→ 感觉太贵先查哪里（核心点③）。

三、先看全局：一次对话的成本由什么组成（02:03 – 02:30）

Claude Code 按 token（模型处理文本的计费单位，约等于大半个英文单词）计费。原文把「一次会话要花多少钱」拆成两个可以分别下手的量 —— 单价（每个 token 卖多少钱）和数量（一个会话一共发出多少 token）。想省钱，要么把单价打下来，要么把数量压下去，整篇文章的所有技巧都落在这两条线上。

成本地图（画面 02:26）：

                  一次会话的成本 = 单价 × 数量
                    ┌──────────┴──────────┐
        单价：每个 token 多贵          数量：一共发了多少
            （核心点①）                    （核心点②）
                    │                        │
   🧠 用了哪个模型                    📦 上下文里有什么
   大模型更贵 —— 所有成本都会被        启动就带上：工具定义 + 系统提示 + CLAUDE.md；
   模型单价相乘。难题用大模型，        会话中累积：读过的文件、命令输出。
   日常任务用小模型（/model）
                    │                        │
   ▭ 输出 ≈ 输入的 5 倍价格           🔁 每轮重发 × 轮数
   思考（thinking）也算输出。用        API 不记得上一轮 —— 每次请求都重发全部历史。
   /effort 控制思考量，日常小改动      同样的三个任务，一个长会话 = 短会话的 1.9 倍 token。
   几乎不需要「深思熟虑」

⚠️ 这张图还有第五行（卡片上边缘在画面底部可见，左右两列各一格，按上下文应是「缓存」与「外包」）。全片没有一帧把它滚进视野——我在 02:10 / 02:18 / 02:26 / 02:28 / 02:32 以及结尾快速回滚的 19:08–19:13 各取帧确认过，第五行始终在画面之下。这是「客观未呈现」，不是我没找到。

图下方的术语约定：

接下来就按这个框架，把左右两半逐个拆开讲。（图里先出现的术语：CLAUDE.md = 项目里每轮自动附给 Claude 的说明文件，详见核心点②的背景二；Prompt 缓存详见 1.3；子代理详见 2.4）

四、核心点①：一个 token 的价格由什么决定（02:32 – 09:24）

三个因素决定单价 —— 模型、输入还是输出、有没有命中缓存。前两个好理解，第三个是大多数新手完全不知道的「隐藏开关」。

1.1 模型：一切的「乘数」（02:32）

同样的 token 数量，大模型的单价更高，所有成本都会乘上模型价格。所以第一问永远是：这个任务配得上大模型吗？

  • 值得上大模型：陌生代码库的排查、复杂的跨文件重构。
  • 小模型就够：格式调整、写简单测试、日常小修小补。

/model # 随时切换模型

口播原话（02:32 起）：「模型是你的这个 token 的价格的一个底座」「所以在不同的任务里面要选择不同的这个模型」。

🚩 口播这里有个转录陷阱，值得单独说：转录文本是「你使用 Facebook 5 这样的模型」和「如果你使用 solid 模型，或者用 deep-seek flash 模型」。回到画面核对 —— 作者自己压的硬字幕写的是 fable-5。所以他说的是 Fable 5（大模型）对比更便宜的档位，不是 Facebook。这类音节失真如果不核画面，脑补出的词往往读起来毫无违和感。（「solid」大概是 Sonnet，「deep-seek flash」我在画面上找不到对应，不硬猜。）

1.2 输入 vs 输出：输出贵得多（03:29）

模型「读」你的上下文叫 prefill（输入），便宜；模型「写」答案叫 decode（输出），大约是输入的 5 倍价格。特别提醒：Claude 的「思考过程」（thinking tokens）也算输出 —— 思考得越久，花得越多。

  • Claude Code 提供 effort 档位：effort 越高，思考越多、越贵。
  • 日常小任务调低 effort：/effort
  • 想彻底关掉思考：MAX_THINKING_TOKENS=0（环境变量，写在 settings.json 的 env 里，或在 shell 中导出）

📌 记住这个量级：输出 ≈ 5 × 输入。在 1.3 的「请求动画」里，红色专指「贵 5 倍的输出」；后面其他图中的红/橙/绿，统一表示「更贵/适中/更省」的相对档位。

页面此处嵌了官方原图（画面 04:50）：

  • Prefill（input tokens）：tool defs → system prompt → CLAUDE.md → msg → files Claude read → command output，图注 one run over the whole request, in the order shown
  • Decode（output tokens）：run 1 …request Read → run 2 …request Read ( → run 3 …request Read ( utils，图注 each run appends one token and runs again — a 200-token response is 200 runs

口播在讲输入构成时把这一条讲得比页面细（03:29–04:46，收在「那这个整个包括的东西就叫输入」）：工具定义要告诉大模型「你提供什么样的工具方法，比如读取、编辑文件、删除文件」；系统提示词「每一个 agent 的工具都会有自己的系统提示词」；CLAUDE.md「每一次对话都会把它加载到上下文里」；再加你自己的话、读取的文件内容、命令输出 —— 这一整包才叫输入。

effort 档位的真实样子（画面 05:10 / 05:18，逐格放大读过）：

Faster ←────────────────────────────────→ Smarter
 low    medium    high    xhigh    max  │  ultracode
                                        │  xhigh + workflows
 May use excessive tokens resulting in ⟨…⟩ overthinking. Use sparingly for the ha⟨…⟩

那行说明文字的中段和末尾分别被硬字幕和画面右边缘截掉，⟨…⟩ 是我的省略标记，不是原文有省略号；档位名和 xhigh + workflows 是逐格放大到能逐字读之后抄的。

📌 口播说「有低中高极高和最高，还有一个最大的」，画面上的实际档位是 low / medium / high / xhigh / max，共 5 档；再往右分隔线之外的 ultracode 是紫色的、标注 xhigh + workflows，它不是第 6 个 effort 档，而是「xhigh + 工作流编排」的组合开关。口播那句「还有一个最大的」对应的就是它，容易听成第六档。作者当时选中的是 max。

1.3 Prompt 缓存：最容易被忽略的省钱开关（05:43 – 09:24）

模型服务商会缓存你对话的「前缀」：如果新一轮请求的开头和上一轮一模一样，缓存命中的部分就按 0.1 倍计价（原价的十分之一）；写一次缓存最多收 2 倍，但只付一次。这就是为什么长对话没有想象中那么贵 —— 历史部分都在打折。

动画：一句 prompt，五次请求 —— 看缓存如何一步步「长大」

页面做了一个可交互动画，控件是 ▶ 自动播放 | ↺ 重置 | 1 | 2 | 3 | 4 | 5 | End（8 个控件逐一点名数过：2 个操作键 + 5 个步骤键 + End；作者点到了 End 的最终态，画面 07:54）。图例：🟢 缓存命中 ×0.1 / 🟠 新增输入 ×1 / 🔴 输出 ×5。

左栏「对话上下文（越攒越厚）」从上往下堆叠：

🔒 系统提示 + 工具定义 + CLAUDE.md
💬 你的消息「修复 utils.test.ts」
📄 Read 调用 + utils.test.ts 文件内容
📄 Read 调用 + utils.ts 文件内容
⚒ Edit 调用 + 修改 diff
✏ npm test 测试输出
📝 一段简短总结（纯输出，未被重发）
↑ 每一次请求，这一整摞都会全部重发

右栏「每一轮：发送了什么 ↔ 模型回应了什么」：

轮 标题 输入侧 输出侧（×5）
1 全部全价 + 写一次缓存 🟠 组装的上下文 ×1（写入缓存） 想了一会儿 → Read：读取 utils.test.ts
2 旧内容走缓存，只有新文件全价 🟢 缓存 0.1× ✓ + 🟠 新文件 ×1 Read：读取被测文件 utils.ts
3 前两轮走缓存，第二个文件全价 🟢 缓存 0.1× ✓（更长）+ 🟠 新文件 ×1 Edit：修改代码
4 之前的内容走缓存，Edit / diff 正价 🟢 缓存 0.1× ✓ + 🟠 diff ×1 工具调用：运行 npm test
5 只有测试输出全价 🟢 缓存 0.1× ✓（越长越便宜）+ 🟠 测试 ×1 一段简短总结（没有工具调用）→ 无新内容，结束

动画结尾的两段结论（这两行在正常播放时始终被硬字幕压住，我靠 19:11 的回滚帧才读全）：

第 5 步 · 结束：测试通过，模型生成一段简短总结。这次没有新的工具调用，也就没有新的工具结果需要追加 —— 所以不会再产生第 6 次请求，任务到这里就结束了。一句看起来简单的 prompt，背后实际发出了 5 次模型请求，每一次都带上到当前为止的完整对话；每一轮极其不对称：输入可能几万个 token，输出只有几百个。

每一轮请求都极其不对称：输入 · 可能有几万个 token vs 输出 · 几百个 —— 输出虽小，单价却约是输入的 5 倍 —— 所以「过度思考」也在悄悄烧钱。

图注：左边是对话上下文的真实构成，右边是每一轮请求的缓存与计价情况。可以自动播放，也可以点数字逐轮讲解 —— 结尾揭示两件事：一句 prompt 背后是 5 次请求；每一轮「输入几万 → 输出几百」，极度不对称。

⚠️ 什么会「打断」缓存

缓存按前缀匹配：一旦开头有任何变化，变化点之后的所有内容都要按全价重新处理一遍。

🍰 前缀断裂示意：断在哪里，哪里之后全价重算 ✅ 理想：在结尾追加新消息 —— 前缀原样命中 （断点之后的整段对话都要按全新价格重新 prefill —— 对话越长，这一下越贵） 断点在哪里，哪里之后的内容就要全价重算 —— 而下面这 6 个操作，每一个都能制造这样的断点。

⚠️ 这张「前缀断裂示意」图的色块主体我没读到。它被夹在 08:26 和 08:34 两个采样点之间，作者一次滚动就翻过去了；我在 08:29 / 08:30.5 / 08:31 / 08:32 / 08:33 / 19:11.2 / 19:11.5 / 19:11.8 共 8 个时刻取帧，只拿到上面这几行文字和「✅ 理想」那一行的开头，色块细节始终没进画面。

真正容易让缓存失效的，是下面这 6 个操作（画面 08:50 / 09:06）

# 动作 说明
1 /model 中途换模型 每个模型都有它自己的缓存。在长对话中途换模型，下一轮可能需要按正常价格重新 prefill 整个会话。
2 /effort 中途调 effort effort level 也是缓存 key 的一部分。中途修改 effort，效果和切换模型类似。
3 ⚡ 中途开启 Fast mode 是否开启 Fast mode（少思考的快速档位开关）同样属于缓存匹配条件。中途开启后旧缓存无法继续匹配，整个会话会按 Fast mode 的价格重新 prefill —— 要用就尽量从 Session 一开始用。
4 /compact 压缩上下文 压缩后只有开头的 system prompt 能继续保留，其余上下文都被压缩。不过只要旧对话还在缓存里，压缩的开销并不大 —— 所以准备离开很久时，最好先 compact 再离开。
5 ⏱ Time：缓存超时 每一轮都会重新计算缓存时间：订阅模式下通常 1 小时过期；API key 默认 5 分钟（设置 ENABLE_PROMPT_CACHING_1H=1 可延长到 1 小时）。超过这个时间，下一轮往往需要重新 prefill 整个对话。
6 📁 恢复旧 Session 缓存大概率已经过期，而且 system prompt 在启动时也会被重新构建 —— 通常同样需要全价重新 prefill。

页面还给了「什么时候做这些昂贵动作」的判断：

✅ 便宜的时刻：会话刚开头、刚 /clear 之后 —— 反正没什么可失去，「切模型 / 调 effort」这些动作放在这里最划算。 ⚠️ 贵的时刻：长对话进行到一半才去切模型。最近几轮走偏想回退？用 /rewind 回到走偏前的轮次 —— 只从尾部剪掉几轮，前面的缓存照常命中，比 /compact 便宜得多。

📌 /rewind 这条口播完全没提。它是「走偏了想回退」场景下比 /compact 更省的选择，实用性不低。 📌 口播讲缓存超时只说了「一个小时之后你又继续对话了，那么它的缓存也是失效的」，漏掉了 API key 默认只有 5 分钟这个更容易踩的档 —— 用 API key 接第三方网关的人受影响最大。

口播在这里给的应对办法（08:51 起）：一系列连续对话里被迫改配置是没办法的事；但任务做完就 /clear 掉重开一个对话，「他就不会去读取这样已有的上下文，不会去触发这样的缓存失效，因为他是从新的开始，就第一句话开始，就不会造成很多累赘了」。

五、核心点②：一个会话会发出多少 token（09:24 – 11:05）

先记住这条铁律：任何东西一旦进入会话，之后每一轮都会重新发送一次。缓存让重发变便宜，但不是免费，而且它一直占着上下文的「座位」。这一部分分两块：先弄懂两个背景（每轮重发、上下文构成），再看四个典型问题与对应的优化技巧。

背景一：每一轮都在重发（画面 09:54）

API 是无状态的：模型不记得上一轮说过什么，所以每轮请求都要把完整历史再发一遍。下面这条传送带会一直向左滚动 —— 想象它就是你的上下文，每一轮都在循环：

传送带色块（从左往右）：提示｜工具定义｜CLAUDE.md｜文件内容 ✓已缓存｜对话轮1 ✓｜对话轮2 ✓｜测试输出 ✓｜对话轮3 ✓｜← 新增内容｜系统提示｜工具定义｜CLAUDE.md｜文件内容 ✓已缓存

↑ 滚动方向 = 请求方向。想减少总量，就是下面四个技巧要做的事：提问更明确（2.1）、输出更安静（2.2）、会话更短（2.3）、脏活外移（2.4）。

背景二：上下文里有什么（画面 10:02）

  • 还没说话就有的：工具定义（告诉 Claude 有哪些工具可用的清单）、系统提示（Claude 每次自带的行为说明）、CLAUDE.md（放在项目里、每轮自动附给 Claude 的说明文件）—— 这是「底座」，每轮都在。
  • 聊着聊着进来的：Claude 读过的每一个文件、每一条命令的输出。

🔍 随手用 /context 看一眼当前上下文的构成 —— 这是发现「谁在偷吃 token」的第一步。

  • CLAUDE.md 要精简：不要塞满整个项目的说明，只留 Claude 干活真正需要的。
  • 定义清楚的工作流 → 用 Skills（放在 .claude/skills/ 的按需加载技能包）：只在需要时才载入，比常驻 CLAUDE.md 划算得多。
  • MCP 服务器（给 Claude 外接工具的服务）自带工具定义：每个都会加进上下文，动辄 10k+ tokens。用 /mcp 查看各占了多少。

作者的真机 /context 演示（10:03 – 11:05）

这是全片唯一的实机数据，逐格放大读过（完整一帧在画面 10:18）：

model as glm-5.3[1m]
Context Usage        glm-5.3[1m]   52.6k/1m tokens (5%)

Estimated usage by category
  System prompt:   3.2k tokens (0.3%)
  System tools:   18.4k tokens (1.8%)
  MCP tools:       4.4k tokens (0.4%)
  Custom agents:   7.3k tokens (0.7%)
  Skills:          9.9k tokens (1.0%)
  Messages:       12.3k tokens (1.2%)
  Free space:    944.5k        (94.4%)

MCP tools      · /mcp             ·  29 tools  ·  4.4k tokens
Custom agents  · .claude/agents/  ·  57 agents ·  7.3k tokens
Skills         · /skills          · 172 skills ·  9.9k tokens
/context all to expand

🚩 这里有一个视频完全没说、但会影响你照做的关键事实：作者的 Claude Code 后端不是 Claude，是 GLM-5.3（1M 上下文）。 状态栏写着 [glm-5.3[1m]] 5% | git:(main) | 1 CLAUDE.md | 3 MCPs | 11 钩子 | tok: 264k (in: 146k, out: 16k)；他在 08:20 打开 /model 菜单时，画面上每一个槽位都指向 glm-5.3：

1. Default (recommended)   Use the default model (currently glm-5.3[1m])
2. glm-5.3                 Custom Opus model (1M context)
3. glm-5.3                 Custom Fable model
4. glm-5.3                 Custom Sonnet model (1M context)
5. glm-5.3                 Cust...
6. glm-5.3[1M] ✓           Cust...        ⚙ xHigh effort ←/→ to adjust

也就是说，他演示「换模型会打断缓存」时，菜单里那几个「Opus / Fable / Sonnet」其实是同一个 GLM-5.3 的别名。这不影响原理（换 model 参数照样会换缓存 key），但如果你照着他的菜单理解「切模型」，会以为自己在换模型档位，实际可能什么都没换。另外他运行的界面是 Orca（左侧有 koubo-help-app / media-manager / work-chat / publish / vibecoding-web / goal-task 六个项目），不是裸终端。

口播据此给的排查思路（10:03 起）：messages 占比很高 → 内容是不是已经做完了、能不能清空重开；MCP 占比很高 → 停掉不需要的 MCP；skills 很多 → 是不是加载了大量用不上的技能。

口播念到了 0.3%（系统提示）、1.8%（工具定义）、0.4%（MCP）、1.2%（messages），跳过了 Custom agents 0.7% 和 Skills 1.0% —— 而这两项在他机器上恰恰是第二、第三大的自选开销（7.3k + 9.9k = 17.2k tokens，比 MCP 的 4.4k 多得多）。57 个 agents / 172 个 skills 才是他这台机器上真正的「常驻税」。

六、核心点③：四个典型场景与优化技巧（11:05 – 17:24）

页面小标题是「⚒ 问题与技巧 · 四个典型场景」，对应导航条上的「③ 排查」。

技巧 2.1 提问指向明确：少走探索弯路（画面 12:58）

❌ 问题：「测试挂了，帮我看看」这类模糊提问会触发一长串搜索 —— Claude 要用 grep（按关键词搜代码）、逐个打开文件试错，整个探索过程留在上下文里，之后每轮重发。开篇那道选择题的答案，正是这个问题。

✅ 技巧：把目标说清楚，探索链立刻变短 —— 问法越具体，Claude 白跑的路越少：

  • 「测试挂了，帮我看看」→ Claude 只能自己 grep、逐个开文件试错，探索痕迹全程占着上下文；
  • 「请修复 utils.test.ts」→ 说清了文件名，读取测试文件和被测文件，一步到位；
  • 「@utils.test.ts 修一下这个」→ 最省：文件内容直接附在你的第一条消息里，Claude 零探索、直接开工。

📎 小提示：同一个会话里 @ 引用一次就够，之后 Claude 记得住，不必每次都带。

技巧 2.2 让命令输出安静下来（画面 12:00）

❌ 问题：命令的输出会整个进入上下文 —— 大目录里 grep 一次，可能就灌进几万 token 的结果。Claude Code 的保护机制（超过约 30,000 字符的输出写进文件、只给开头预览，BASH_MAX_OUTPUT_LENGTH 可调）也管不到真正的危险区：30k 以下，比如 400 行「测试全绿」—— 每一行都在稀释关键信息，还每轮重发。

✅ 技巧：让输出只留下有用的部分 ——

  • 用安静模式的 flags：npm run -s test、git log --oneline、pytest 的 -q、构建工具的 dot 进度。
  • 更省心的做法：把「带安静 flag 的完整命令」直接写进 CLAUDE.md —— 例如「跑单个测试文件用 npx vitest run <file> --reporter=dot」。Claude 不用再摸索命令，还能省下几百行输出（也可以用 hook 自动加安静参数）。

📎 判断标准很简单：这条输出里，对任务有用的信息占比有多高？「全绿的 400 行」有用的只有最后一行。

作者在这里切到真实终端跑了一次 git log（口播 11:44「就比如说像我们现在这样执行 git log」；我看到的终端帧落在 11:46–12:02），然后对比 git log --oneline（口播转录成「Gitlog 1LAM」，硬字幕作 git log --oneline），用来说明「这个是占用的上下文长度是非常多的」。

这个演示碰巧比页面的说法更有说服力。放大数了那一屏（11:54）的 5 条完整 commit：每条固定占掉 commit <40 位 hash> / Author: xiaowei <xiaowei@qq.com> / Date: … 三行样板，其中 4 条还各带一行 Co-authored-by: Cursor <cursoragent@cursor.com>（第 3 条 feat: build topic research and AI collaboration workbench 没有）。也就是说 5 条 commit 里，真正是信息的「标题行」只占约四分之一，剩下四分之三是 hash、邮箱、时区和署名 —— 这正是页面说的「这条输出里，对任务有用的信息占比有多高」。

（顺带两个旁证：作者的 git 身份是 xiaowei，与地址栏里的 /Users/xiaowei/.zcode/workspace/… 对得上；他这个仓库同时也在用 Cursor Agent 干活。）

技巧 2.3 按主题拆会话，及时翻篇（画面 14:10）

❌ 问题：长会话上下文越攒越多，每一轮都在为所有历史买单。同样三个任务，「一口气做完」和「每个任务一个短会话」差多少？看官方给出的对比：

📊 同样的三个任务，两种做法的 token 总量
   🟢 推荐：任务之间 /clear → 合计 1.0×    🔴 不推荐：一个长会话连做 → 合计 1.9×

✅ 三个短会话（任务之间 /clear）
   [任务1] /clear清空 [任务2] /clear清空 [任务3]   → 合计 1.0×（只重发自己）

❌ 一个长会话（连着做）
   [任务1] [任务2 = 自己 + 重发任务1的历史（任务1 变成了甩不掉的行李）]
           [任务3 = 自己 + 重发 1+2 的全部历史（上下文越滚越大）]      → 合计 1.9×（多付近一倍）

长会话不是「错」—— 深入调试时值得。但要清楚：它每一轮都在为更长的历史买单。 💡 结论：按「主题」开会话，做完一个就翻篇 —— 一个任务一个会话。 （图注：重绘自原文对比图（柱宽为示意，非实测数据）：同样的三个任务，一个长会话约消耗 1.9 倍 token。）

页面在这一节末尾还挂了 5 条实操补充（只在结尾 19:13 快速回滚时完整出现过一帧，正常讲解时被跳过）：

  • 舍不得丢上下文？/compact 想保留的说明 —— 把历史压缩成摘要再继续。
  • 准备休息或切走？趁缓存还热先 /compact —— 订阅的缓存约 1 小时过期，趁它还在时做摘要，比过期后全价重来便宜得多。
  • 可以告诉它压缩时保留什么：在 CLAUDE.md / 设置里配置 Compact instructions。
  • 用 1M 上下文模型的用户：/autocompact 200k（v2.1.221+）把自动压缩阈值调低，避免上下文涨满才压缩。
  • /loop 很贵：它会反复触发 Claude。运行它时，最好开一个全新的终端窗口。

口播在这一节延伸出一个页面上没有的用法（13:40–14:50），也是全片作者个人经验最集中的一段：

「比如说我们使用一些技能，不管是 superpowers 还是 Multi skills，我们如果在沟通过程中会产生一些文件，比如说 plan 文件或者具体的计划……我们就马上把上下文清空掉，然后让模型去读取这个文件，然后再去执行。」 「因为我们其实所有跟模型之间的沟通，最终落地的（是）文档，那个沟通的过程的内容是没有任何意义的。」 「特别是我们使用 [Multi skills]，用 [gremlin with Docs] 的时候，如果他问你 50 个问题，那么这里面产生的上下文是非常长的。当他确定好了之后，然后你使用这个命令去执行，比如说 to SPEC 或者 to PRD 产生文件文档之后，那么你就直接去清空掉对话，或者新开个对话，去让他读取这样的文件，然后去接着往下执行，那这样的效率是最高的。」

📌 专名说明（做过画面核对，不硬猜）：

  • superpowers、Multi skills、to SPEC、to PRD —— 四个都在作者自压的硬字幕上原样出现（13:43 / 14:26 / 14:38），可信。to SPEC / to PRD 在转录里被听成了「ToSpec / ToPID」。
  • gremlin with Docs（14:27）—— **这是作者硬字幕上的写法，转录是「Greeming with DOS」，两者对不上，我无法从本片确定它指哪个命令。**从上下文（先追问几十个问题，再产出 spec/prd 文档）看更像是某个「追问式需求澄清」的 skill，但这是推测，不作为事实。

技巧 2.4 把高输出的脏活外包给子代理（画面 14:58）

❌ 问题：日志分析、全量测试这类活「输出巨大、答案很小」，让主会话亲自干 —— 巨量中间过程会留在上下文里，之后每轮重发。

✅ 技巧：外包给子代理 —— 一个拥有独立上下文的 Claude 实例：有自己的系统提示、工具集和 CLAUDE.md，但看不到你的对话历史。它干完活，只有最终答案被带回主会话，其他一切直接丢弃。

🏠 主会话（你的对话）                        🚀 子代理（独立上下文，与你隔离）
  💬 你：「分析一下构建日志，为什么挂了」        📋 自带：自己的系统提示 + 工具 + CLAUDE.md
  🤖 Claude：我派一个子代理去处理     ──派出任务──▶ 🔧 干脏活：读完整日志 / 反复跑测试（输出量巨大）
  （上下文保持干净 —— 没有日志、没有中间过程）    🔍 中间过程：grep、翻文件、报错堆栈……
  ✅ 主会话只收到：最终答案          ◀──只带回答案── 🗑 任务结束：除答案外全部丢弃，不占主会话一个 token

划算场景：输出巨大、答案很小的任务（日志分析、全量测试）；小任务反而可能亏（子代理要重读文件、自己也要花轮次）。 高输出、低保留的任务最适合外包。重复出现的脏活，用 /agents 定义一个专用子代理（模型可指定 haiku / sonnet 等便宜档）来干。

页面接着放了官方原图（画面 17:14）：

再放大视角看一张原文的图 —— 「一次对话，四个上下文」：你面对的主会话是 1 个上下文；它同时派出的 3 个子代理（翻构建日志、跑完整测试、搜 git 历史），又各自拥有 1 个独立上下文。注意三个细节：

  • 启动成本各自要付一份（紫色部分）：每个子代理都要带上自己的系统提示 + 工具 + CLAUDE.md，这是「同时跑几个上下文」的固定开销；
  • 中间过程全部留在子代理自己的上下文里（橙色「读了什么、跑了什么」）：巨量输出不进主会话，任务完成即整体丢弃（discarded when done）；
  • 只有绿色的一小段「答案」被带回主会话，追加到你的对话末尾，继续参与后面的轮次。

图例（原文配色）：紫色 = 启动内容（每个上下文各付一份）；蓝色 = 你们的对话；橙色 = 子代理读了/跑了什么（用完即弃）；绿色 = 最终带回主会话的答案。

口播的例子（15:39 起）：Java 里有个空对象异常，「那么这个时候你就开启一个子代理，让他去排查，通过读取日志去排查这个原因，然后再把原因告诉你，那么你直接再去修复」——「我们要的其实是这个问题的结果，你判断的过程，我们是不关注的」。

📌 页面明确写了「小任务反而可能亏」和「每个子代理的启动成本各自要付一份」，口播完全没提这个反面，只讲了省。三个子代理 = 三份系统提示 + 三份 CLAUDE.md，小活外包是净亏的。

七、总结：常用的方法（17:24 – 19:03）

页面导语：「原文结尾 TL;DR 给出的六条建议 —— 正好对应前面的核心点 ①②③，也是日常最常用的六个习惯。」六张卡（画面 18:42）：

# 卡片 内容
1 🧠 选对模型 难题用大模型，日常任务换小模型（/model）—— 模型价格会乘在所有成本上。
2 ▭ 调低 effort 输出 ≈ 输入 5 倍价，thinking 也算输出。日常任务用 /effort 调低，机械任务可 MAX_THINKING_TOKENS=0 彻底关掉思考。
3 ⚡ 守住缓存 昂贵动作（切模型 / 调 effort / fast mode）放在会话开头或 /clear 之后做；休息前趁缓存还热先 /compact。
4 📦 上下文保持精简 CLAUDE.md 只留必需的，工作流交给 Skills 按需加载；用 /context 和 /mcp 定期检查谁在占上下文。
5 🎯 提问指向明确 能 @ 文件就 @ 文件，让内容直接进第一条消息；常用命令写进 CLAUDE.md 并带上安静 flag（如 --reporter=dot）。
6 ✂ 按主题拆会话，脏活外包 一个任务一个会话（/clear 前先 /rename）；要保留就 /compact；高输出、低保留的活交给子代理。

页脚：「📖 本页内容改编自 Anthropic 官方博客《Maximizing the value of your Claude Code sessions》（2026-08-14），按原文顺序逐点图解」

八、我对着官方原文做的核查（三处需要打折）

我抓了官方原文全文（31,355 字符纯文本）逐项比对。

✅ 对得上的：所有硬数字

数字 页面 官方原文
输出 ≈ 输入的 5 倍 ✓ 5x ✓
缓存命中 0.1 倍 ✓ 0.1x ✓
缓存写入最多 2 倍 ✓ 2x ✓
输出落盘阈值 30,000 字符 ✓ 30,000 ✓
订阅缓存 1 小时 / API key 5 分钟 ✓ ✓
/autocompact 200k ✓ 200k ✓
400 行「测试全绿」的例子 ✓ “a test runner that prints 400 passing tests” ✓
ENABLE_PROMPT_CACHING_1H、MAX_THINKING_TOKENS、BASH_MAX_OUTPUT_LENGTH ✓ 三个环境变量全部出现 ✓

命令清单也完全覆盖：/clear /model /effort /compact /context /rewind /mcp /rename /autocompact /loop。

🚩 第一处：「1.9 倍」不是官方数字

页面把它写了三遍（成本地图、2.3 的图例、2.3 的图注），视频口播也说「看官方给出的对比」「这边我们可以看一下」。

官方原文全文里 1.9 出现 0 次。 原文这一节（How many turns it stays there）的原话是：

“One long session costs more than the same work spread over a few short ones, and by more than you’d think, because turn 40 is also re-reading the 39 turns before it.”

只有「比你想的更多」这个定性判断，没有任何量化。配图是一条成本随轮次上升的曲线，图注就是那句话本身。

公平地说，页面自己在图注里标了「柱宽为示意，非实测数据」——所以这不是刻意造假，是二次创作时为了画柱状图补了一个示意值。但 1.9× 同时出现在成本地图的「数量」分支上（那里没有任何免责声明，读起来就是一条结论），加上口播的「官方给出的对比」，观众很容易把它当成 Anthropic 测出来的数。引用这个数字时请注明它是图解页的示意值。

🚩 第二处：「6 个技巧」和官方的「6 条 TL;DR」不是同一组 6 条

官方 TL;DR 六条（原文）：

  1. Run /clear between tasks.
  2. Set your model and effort level before you start. Changing either one mid-conversation can bust your prompt cache.
  3. @-mention files instead of naming them.
  4. Add quiet flags to noisy commands, or run them in a subagent.
  5. Run /context once in a fresh session.
  6. /compact before you take a break from your keyboard.

页面六卡：选对模型 / 调低 effort / 守住缓存 / 上下文保持精简 / 提问指向明确 / 按主题拆会话+脏活外包。

数量凑巧相同，映射却是错位的，而且是双向错位：

官方 TL;DR 页面怎么处理的
2. Set your model and effort level before you start 一条拆成三条：选对模型 / 调低 effort / 守住缓存。原文的重点是「开工前就定好，别中途改」，页面把「选什么」独立成两条讲，「before you start」这个真正的要点被挪进了第三条「守住缓存」里
4. Add quiet flags to noisy commands, or run them in a subagent 一条里的附属句被提升成独立一节：官方把「子代理」当成「命令太吵」的另一种解法写在同一条里；页面给了它独立的技巧 2.4 + 一整张官方配图 + 总结卡第 6 条的后半
1. /clear between tasks + 6. /compact before a break 两条合并进「按主题拆会话，脏活外包」和「守住缓存」两卡里
3. @-mention files / 5. Run /context once 基本一对一（→ 提问指向明确 / 上下文保持精简）

结论：页面（和视频标题）的「6 个」是重新归并的结果，不是官方那 6 条。 归并本身不算错——页面按「单价 / 数量」的框架重排更好教——但两个副作用值得知道：① 官方最强调的 before you start 在页面里降格了；② 官方只是顺带一提的子代理在页面里被放大成了四大技巧之一（这是我个人判断：对新手来说，「开工前设好模型和 effort」比「学会用子代理」的性价比高得多，而页面的篇幅分配是反过来的）。

🚩 第三处：演示环境不是 Claude 官方模型（详见第五节）

全片唯一的实机数据来自跑在 GLM-5.3（1M 上下文） 上的 Claude Code，且 /model 菜单里所有别名槽位都指向同一个 GLM-5.3。缓存机制、effort、/context 这些属于 Claude Code 客户端的行为可以照看；但定价倍数（5×/0.1×/2×）是 Anthropic 官方模型的价目，换成第三方网关后能不能享受到同样的 prompt cache 折扣，本片没有验证，也不能想当然。

九、值得单独拎出来的三条（口播和页面都埋得比较深）

  1. /rewind 比 /compact 更适合「走偏了想回退」：只剪掉尾部几轮，前面缓存照常命中。全片口播零提及。
  2. API key 的缓存默认只有 5 分钟（订阅是 1 小时），可用 ENABLE_PROMPT_CACHING_1H=1 延长。用第三方 API 的人最该记这条，而口播只说了「一个小时」。
  3. 子代理不是无脑省：每个子代理都要各付一份「系统提示 + 工具 + CLAUDE.md」的启动成本，小任务外包是净亏。页面写了，口播只讲了省的那一半。

附录：画面上的一整屏「彩蛋」——/doctor 技能文档（口播零提及）

作者切到 Orca 演示 /model、/effort、/context 时（画面 08:20 与 10:10 两处），终端里停留着他自己刚生成的一份文档 docs/claude-code-doctor-skill.md（Thought for 14s、Cogitated for 2m 48s、正文 +244 lines）。这不属于本视频的讲解内容，但它的主题恰好是「省 context」，而且是全片信息密度最高的一屏，逐字抄录如下：

一句话总结这个技能 /doctor 是 Claude Code 的环境体检 + 清理工具：它只读扫描你的安装、扩展使用情况、CLAUDE.md 记忆文件、hooks 性能、版本和权限配置，产出一份带明确建议的报告，经你确认（最多 2 个问题）后才应用修改，且所有操作可逆。

它的三个核心价值

  1. 省 context：找出装了但从不用的 skills/MCP 服务器/插件，删掉 CLAUDE.md 里“读代码就能推导”的内容，把任务流程迁移成懒加载的 skill —— 每次会话都少付 token。
  2. 修隐患：损坏的 JSON 配置（会被静默忽略）、重名冲突的 agent 定义、重复安装、慢 hooks、落后的版本。
  3. 减少打断：把 defaultMode 设为 auto（分类器代替弹窗），给高频被拒的只读命令配精确 allow 规则。

它最特别的两点设计

  • 权限变更与清理严格分离：放宽权限（Check 8、9）的确认是独立问题，绝不混进 declutter 确认里 —— 同意清理 ≠ 同意放宽安全姿态。
  • 自身就是安全范本：配置只按 key 读取（防密钥入对话）、采集的名称绝不插值进 shell（防注入）、转录内容只用于计数（防提示注入）、拒绝证据只认 CLI 打标字段（防恶意 MCP 伪造）、npm 查询固定 registry 且在 HOME 执行（防恶意 .npmrc 劫持）。

文档包含十项检查的详细说明、数据来源表、报告流程图、安全边界和适用场景，可直接作为团队分享或参考材料使用。

它的第 1 条价值（省 context：清掉不用的 skills/MCP）正是本片技巧 4「上下文保持精简」的自动化版本 —— 而作者自己那台机器上有 172 个 skills（9.9k tokens）+ 57 个 agents（7.3k tokens），是全片最需要这个工具的样本。

顺带一个转场画面给出了这份文档的由来：11:04 切窗口的瞬间，终端底部闪过一行红字 ✗ Auto-update failed · Run claude doctor —— 他大概是被这行提示引到 claude doctor 上，才顺手让 Claude Code 把它写成了一份 skill 文档。

说明：这份文档是作者的产物，不是官方 skill 文档；我没有在本机验证过 /doctor 是否真有上述十项检查。此处仅作原样转录。

十、覆盖率与方法声明

做了什么

  • 全片转录：whisper large-v3-turbo，-mc 0 -bs 5 -et 2.8，563 行，结尾自然收尾（无截断）。
  • 均匀抽帧：ffmpeg -ss <t> -frames:v 1，每 8 秒一张共 145 张，md5 去重验证 145/145 全部唯一（不是 fps= 滤镜，避开重复帧陷阱）。
  • 漏采扫描：每秒灰度小图（裁掉硬字幕带与浏览器 chrome）逐秒差分切段，得 80 段、其中 50 段稳定 ≥4 秒；比对采样点后补抽 30 个未覆盖段，另按需补抽 36 帧（含 0.2 秒级）+ 十余张定点裁切放大图。
  • 引文定位：字幕拼接串匹配（非 grep -F，可跨字幕条），分三批共查 29 条，28 条完整命中（其中 1 条跨 2 条字幕）、1 条部分匹配（我的检索串与转录用词不同，已换句重查，未采用部分匹配结果）。
  • 交叉核查：抓取 Anthropic 原文全文纯文本，对数字、命令、环境变量、TL;DR 逐项比对（1.9 在全文中出现 0 次）。
  • 数字复核：/context 里的 29 tools / 57 agents / 172 skills 三个计数，先是在缩略拼图上读到的，按惯例回去放大核对时，620–658 秒那几帧的左边缘已被裁掉（作者中途放大了终端），差点据此改写成「读不到」；退回到 10:18 那一帧才拿到完整显示并确认三个数无误。判据要选对帧，「这几帧读不到」不等于「画面上没有」。

明确没做到的

  1. 成本地图的第五行（左右各一格）全片未进入画面 —— 6 个时刻取帧确认过，是客观未呈现。

  2. 「前缀断裂示意」图的色块主体未读到 —— 8 个时刻取帧，只拿到标题与说明文字。它被夹在两次滚动之间。

  3. 「gremlin with Docs」这个命令名无法确定所指（转录与作者硬字幕互相矛盾），已按原样标注存疑，未推断成任何具体 skill 名。

  4. 口播中的「solid 模型」「deep-seek flash 模型」两处专名画面上没有对应物，未强行还原。

  5. 抽帧只能证明「每一屏都进过视野」，不能证明「进过视野的都写进来了」。这一项没有自动化保证，只能逐节回查。本文回查了两轮，第二轮（全文重读、专找「一句话概括了多个画面」的地方）又改出 7 处：

    • 交叉引用指错节号（「见第五节」实为第八节）；
    • 动画控件数从 7 改成 8（自动播放 / 重置 / 1 / 2 / 3 / 4 / 5 / End，第一轮漏数了一个）；
    • 「前缀断裂图夹在 08:30 和 08:34 之间」→ 采样点实为 08:26 和 08:34（我按 8 秒步长算错了格）；
    • git log 终端画面的时间范围 11:34–12:00 → 实为 11:46–12:02（第一轮把一张浏览器帧当成了终端帧）；
    • 「每一条 commit 都带 Co-authored-by」这个全称断言不成立 —— 放大数过，那一屏 5 条里 4 条带，第 3 条没有；
    • 引文统计从「15 条全部命中」改为「三批共 29 条，28 条完整命中 + 1 条部分匹配未采用」；
    • 官方与页面的映射关系写反了：第一轮写「官方独立成条的子代理在页面里是附属项」，实际相反 —— 子代理在官方只是第 4 条里的一个附属句，是页面把它提升成了独立一节。

    这七处里，只有前三处属于「写错了」；后四处都是「写少了 / 写反了」，全部来自第一轮把多个画面压缩成一句话时省掉的核对。

日期 文件名 260824 是我的下载日，不是录制日。片中可确定的绝对日期只有官方原文发布日 2026-08-14（页面标签 + 官方站均可查）；口播说「前两天」发布，据此录制约在 08-16 前后。Orca 状态栏里的 5d 23h、646h 13m、Done - Claude 3d 都是相对时间，无法锚定到具体日期，所以这个 08-16 只是软推断。

← 返回 Agent 开发