你以为的 AI 编程：聪明、便宜、丝滑。现实：账单像比特币

我开 Claude Code 第一周写了一篇博客，第二周顺手改了几个 bug，第三周 Anthropic 发来一封"温馨提醒"邮件——当月账单已超过 $180。第四周月结一出，$214。我把那张账单贴在便签里压在显示器底下，至今没撕。

那一刻我盯着仪表盘想了很久。明明只是写代码、改文档，为什么烧得比开三台 EC2 还快？我问朋友们大家都用多少，得到的回答从 $30 到 $400 不等，差距最大的两个人写代码强度其实差不多——区别在于他们跟 AI 的"相处姿势"完全不一样。

为了搞清楚自己烧在哪，我把过去三十天的 usage CSV 拉下来逐条复盘，发现一件让我有点羞耻的事：真正写代码的 token 不到 30%，剩下的全是会话里那些"我以为不要钱"的废话。

塞进去的整本 SKILL.md、cat 出来的几千行日志、连续聊了四小时却没 /clear 一次的祖传上下文、子任务没有隔离搬来的全套主会话历史、想到啥问啥的"碎片闲聊"——每一项都像水龙头没拧紧，单看不疼，攒一个月就是一辆共享单车。

调整了两周后，账单稳定在 $40 上下，输出量没降，反而因为上下文更干净，AI 干活更准、错误更少。这篇文章把这两周抠出来的 7 个技巧整理一下，按"性价比 / 立刻能做"的顺序排好。每条都附我自己的踩坑——别问怎么知道的，问就是钱花过。

系列前作：把本地 Memory 与 QMD 接进 OpenClaw：我是怎么把 Token 砍掉一半的。前作讲架构层怎么把历史会话压成可检索的笔记，这篇讲战术层——日常写代码时的 7 个具体动作。两篇互补，配合食用味道最佳。

钱去哪了？先认识三只"吞金兽"

要省钱，先得知道贵在哪。我把账单拆开后发现，Claude Code 的 token 消耗几乎全卡在三个地方：

剩下 10% 才是"实际写代码"。看着是不是有点反直觉？这就是为什么"少写功能"省不了多少钱，真正能砍开的是上下文怎么进、子任务怎么切、缓存怎么用——这三件事跟"业务"没半毛钱关系，全是工程姿势。

更扎心的一个细节：Claude API 的 input token 价格虽然比 output 便宜，但重度对话场景下 input 量是 output 的 30~80 倍。也就是说，AI 写一个一百行的函数，你以为是为这一百行付钱，其实你是为"AI 看完整套上下文然后吐出一百行"付钱。

把上面这张表贴在显示器边上，下面 7 招都是在打这三只兽。每一招我都会注明它主要打哪一只。

顺便讲讲为什么 Context 堆积这么贵

这点很多人理解不到位，我多花点篇幅讲清楚。Claude 的对话不像微信聊天——你发一条新消息，模型并不是只读你这一条，而是把整个会话从开头重新读一遍，再算下一条回应。

所以一个 50 轮对话的会话，第 50 轮的 input token 大致是：

T_50 = system_prompt + (T_1_prompt + T_1_response) + ... + (T_49_prompt + T_49_response) + T_50_prompt

看到了吗？第 50 轮要为前 49 轮全部付费。这就是为什么“聊到下午时单条消息变成 60k+”——不是某一条特别长，而是历史在背后悄悄叠加。

更黑暗的是：每条历史消息都只有“开头那一段”能进 cache，后续追加的对话内容大多是 cache miss 价。也就是说，长会话不仅 input 变大，单价还变贵。

这套机制下，/clear 不是“清屏”，而是“重置计费起点”。理解这一点，下面招式三、四、六的逻辑就全通了。

招式一：把 prompt cache 命中率冲到 90%+（主打 Cache Miss）

Anthropic 的 prompt cache 价格表写得很清楚：cache 命中是 miss 价格的 1/10。这句话翻译一下——如果你能让 system prompt 永远走 cache，开场费直接打 1 折。

但很多人没意识到一个细节：

5 分钟内同一份 system prompt 第二次进来，自动走 cache 价。一旦超过 5 分钟空窗，cache 就被 evict 掉。

也就是说，只要你的"开场白"够稳定、操作够连贯，账单可以直接砍 80%。但我以前老是把这事搞砸——

错误姿势一：边用边改 SKILL.md。我喜欢把 SKILL.md 一改就重启会话验证，每次重启都是一次 cache miss。一上午改三次 SKILL.md，等于把开场白全价付了三遍。

错误姿势二：长任务中间去摸鱼。写代码写一半切去刷小红书，半小时后回来继续。Cache 早被 evict 了，回来那一下相当于重新付了开场费——我管这叫"咖啡税"，去倒一杯咖啡的工夫，账单多 $0.3。

错误姿势三：频繁切换 model。/model opus 一下，/model haiku 一下，每次切都重新付 system prompt 的 miss 费。

调整后的姿势：

1. SKILL / 工具配置改完攒一批再重启，别像调收音机似的反复 reload。养成"每天开工前统一 review 一次配置"的节奏。
2. 长任务一气呵成。会话间隔超过 5 分钟，cache 就被 evict 了。如果中途真要走开，至少在临走前发一条"你先把刚才的方案写成 markdown"让 AI 处于活跃状态。
3. 用 router 配置而不是手动切 model。OpenClaw / Claude Code 都支持把 model 配成 router（比如我现在用的 9router/article-pool），让 router 在背后做模型选择，你这边维持稳定开场白，让稳定路径享受 cache，让动态路径走便宜模型。
4. 关闭那些"自作聪明"的 IDE 插件。有些插件每开一个文件就向 AI 询问一次"要不要分析这个文件"，背后偷偷打了几十次 API。一开始我没注意，账单里看到大量 cache_creation_input_tokens 才意识到问题。

实测一周后，我看 usage 报表里 cache_read_input_tokens 这一列从原来 30% 涨到了 78%——这一项就把每天的开场费砍了 70% 以上。一天开 10 次会话，原本 $4，现在 $1.2。

招式二：SKILL.md 瘦身——从"百科全书"改成"目录索引"（主打 Cache Miss）

Claude Code 启动时会把所有可用 Skill 的 SKILL.md preamble 全部拉进 system prompt。一个 Skill 三百行，二十个 Skill 就是六千行——还没干活就先吃掉了 8k token，而且每次重启会话都吃一遍。

我之前最离谱的状态：每个 Skill 里写了"完整教程 + 所有 CLI 参数 + 错误码字典 + FAQ"，自以为 AI 一看就会。结果一查 system prompt 占用，惊掉下巴——光是我自定义的 7 个 Skill 就吃了 12k token。

后来我把所有 Skill 改成两层结构：

# 顶层：只放"何时使用"+ 关键路径（≤ 30 行）
SKILL.md           ← 永远进 system prompt，必须精简
↓ 触发后用 read 加载
- DETAILED.md      ← 完整步骤、长 example
- TROUBLESHOOT.md  ← 错误码字典、FAQ
- examples/*.sh    ← 可执行脚本，按需读

SKILL.md 里只回答两个问题：“什么场景下激活我” 和 “激活后第一步去 read 哪个文件”。其他细节全部下沉。

举个具体的对照例子。改造前的 r2-upload/SKILL.md：

# r2-upload Skill

## 介绍
Cloudflare R2 是一个 S3 兼容的对象存储服务……（200 字介绍）

## 安装
1. 安装 rclone……（30 行步骤）
2. 配置 token……（25 行）

## 使用方法
### 单文件上传
rclone copy local r2:bucket/path
…

### 批量上传
…（再来 50 行）

## 常见问题
Q1: 403 错误怎么办？……（3 段）
Q2: 域名解析失败……（2 段）
…

总长 280 行。改造后只剩这样：

# r2-upload

## When to use
用户提到上传图片/文件到 R2、img.softon.top、图床、Cloudflare 对象存储时激活。

## Quick path
1. read DETAILED.md 看完整步骤
2. 上传脚本：~/bin/r2-upload.sh <local> [filename]
3. 出错先看 TROUBLESHOOT.md

不到 15 行。需要详情时 AI 主动 read DETAILED.md，按需付费。

效果一目了然：

8k token / 次 的开场费没了。一天开十次新会话，就是 8 万 token。

不知道怎么写紧凑 SKILL.md 的，可以参考 OpenClaw 自带的 taskflow、weather，那两个的精简度刚刚好——前者覆盖了任务编排这种复杂场景，SKILL.md 还是控制在 50 行内；后者更极致，20 行解决问题。

我自己定的红线：任何 SKILL.md 超过 60 行立刻拆。超过的部分一律下沉到 DETAILED.md 或 examples/。这个规矩立起来后，新写 Skill 的速度反而快了——“目录页"逻辑天然让人写得简洁。

招式三：/clear 比你想的早得多（主打 Context 堆积）

最违反直觉的一招：任务切换之间，立刻 /clear。

我有个坏习惯——一个会话从早聊到晚，上午写博客、中午改 nginx、下午调 Hugo 主题、晚上还想着顺手 debug 个 LXC。每次切换都不 clear，理由听起来很合理：“说不定下个任务还要用上面的上下文呢。”

真相：99% 不会用到。但每条新消息都要把前面所有的代码、报错、文件内容重新算一遍 input token。一段 4 小时的混合会话，到下午时单条消息 input 已经飙到 60k+——而你真正在解决的问题可能只用得上其中 3k。

来看一段我以前一天的 usage 截面：

最后那两小时，我每问一次 AI 都在为上午的博客付钱。账单当然大头都集中在下午。

我现在的纪律：

• 每个独立任务，新开会话或 /clear 一次。“独立"的判断标准：换了一个项目目录，或者换了一类问题（比如从写代码切到运维）。
• 长任务进行中需要查无关资料？用子会话（招式四），别污染主会话。
• 实在不想新开，就用 /compact 让 Claude 自己总结一下当前会话，把历史压成几百 token——比手动 /clear 友好，缺点是会丢一点细节。
• 晚上睡觉前 /clear 比早上起来 /clear 划算——隔夜的会话再连上来，前一天的所有上下文都还要重新计费。睡前清掉，明早干净开局。

只这一招，我把单会话 input token 中位数从 35k 砍到了 8k。砍掉的全是没用的回忆。

/clear 与 /compact 怎么选？我的判断：

招式四：让 sub-agent 啃重活，主会话只下达命令（主打 Context 堆积）

OpenClaw / Claude Code 都支持 sessions_spawn 出一个子 agent。很多人没用对——他们当成"另一个聊天窗口”，结果发现子 agent 启动时把主会话的所有历史 fork 了过去，等于花了两份 token。

正确姿势：isolated 模式。

# OpenClaw 里的写法（伪代码）
sessions_spawn(
  task="读 /var/log 里所有 error 日志，提炼出 top 5 报错类别",
  context="isolated",     # 不继承主会话
  runtime="subagent"
)

要点：

1. context="isolated" 是关键参数。默认 fork 会把主会话历史一并复制，子 agent 一启动就吃掉几万 token。改成 isolated，子 agent 只看到你给的 task 描述。
2. 主会话里把"重活"明确委托出去——大文件分析、批量改文件、长串测试日志解读，全部丢给子 agent。
3. 子 agent 干完只回一句结论，主会话的上下文永远干净。

什么活适合外包？我整理了一份：

什么活不适合外包？需要持续来回讨论的、需要主会话当前上下文的、依赖你刚刚做的某个决定的——那种就老老实实在主会话做。

我用这个套路写这篇文章：主会话只跟我交流大纲，让子 agent 去 NAS 翻历史选题、读前作内容、做对比表格。整个写作过程主会话上下文没超过 12k token。

子 agent 的 task 描述怎么写？我的模板：

[目标] 读 /var/log/syslog，提炼最近 7 天的 top 5 报错。
[输入] 文件路径：/var/log/syslog
[期望输出] markdown 表格，列：报错关键词 / 出现次数 / 第一次出现时间。
[禁忌] 不要把日志原文返回，只要总结。

四行格式，[目标 / 输入 / 输出 / 禁忌]。最后那条"禁忌"特别重要——不写的话子 agent 经常会"贴心"地把原始日志大段塞回主会话，前面省的钱白省了。

一句话总结：把"看 5000 行日志"这种活外包给一次性打工的 agent，主会话保持高管姿态。

招式五：工具输出截断与摘要化（主打 工具日志噪音）

我曾经写过一行让自己很心痛的命令：

cat /var/log/syslog

这条 syslog 4 万行。Claude Code 老老实实把它全读进来了。那一次 input token 11 万，账单瞬间多扣 $0.7。一行命令喝掉一杯瑞幸。

血的教训之后，我给所有"读取类"工具调用加了三条铁律：

1. 永远先 wc -l / du -h 探一下大小——超过 1000 行或 1MB 就触发摘要逻辑。
2. 用 grep / head / tail / awk 取最相关那几屏，别让模型自己消化全文。
3. 结构化数据用 jq -c 压成单行——同样一份 JSON，多行 indent 比 minified 多吃 30% token。

具体怎么落地？我把这套思路写进了一个 helper 函数，伸手就能拿：

# ~/.bashrc 里的小工具
peek() {
  local f="$1"
  local lines=$(wc -l < "$f")
  if [ "$lines" -gt 500 ]; then
    echo "==== first 50 ====" && head -50 "$f"
    echo "==== last 50 ====" && tail -50 "$f"
    echo "==== total: $lines lines ===="
  else
    cat "$f"
  fi
}

# 进阶版：grep 模式
grepN() {
  # grepN <pattern> <file> [context_lines]
  local ctx="${3:-3}"
  grep -nC "$ctx" -m 20 "$1" "$2"
}

# JSON 压缩取样
jsample() {
  jq -c '. as $r | if type=="array" then .[0:3] else . end' "$1"
}

然后跟 Claude 说"用 peek 看那个文件"，它就再也不会一口气吞掉一整个 syslog 了。

类似的还有：

每一条单看好像没省多少，叠在一起一周能省下两顿火锅。

还有个进阶技巧——让 AI 主动选择截断。在 SKILL.md 里写一条"读文件前先 wc -l，超过 500 行使用 head/tail 取头尾"，AI 自己就会执行这套纪律，你不用每次提醒。

招式六：本地知识库替代"上次咱聊过"（主打 Context 堆积）

第二贵的吞金兽是 context 堆积。第二贵的解药是——别让 AI 翻历史会话找答案，让它去读你写好的笔记。

人脑怎么做决策？不是每次回忆全部经历，而是看一眼笔记本就开干。AI 也该这样。

我现在的实践（也是前作 openclaw-local-memory-qmd-token-reduction 的延伸）：

1. 重要决策 / 配置 / 凭据落地到 MEMORY.md——主会话开场默认 read 这一份，几百 token 搞定，比"翻 200 条历史消息找 IP"省一万倍。
2. 每天的进展写到 memory/YYYY-MM-DD.md——之后要回忆"两周前我装 R2 的时候踩了啥坑"，按日期 grep 就行，不用让 AI 在 30k 历史里大海捞针。
3. 复杂方法论（比如本文这种 7 招）整理成 SKILL 或 markdown——下次需要时让 AI read SKILL.md，比"我再给你讲一遍"便宜 100 倍。

我自己 MEMORY.md 的结构（脱敏示例，你按自己的环境填）：

# 长期记忆

## 服务器与凭据
- NAS: 内网 IP / SMB 用户与密码：见 .secrets/nas.txt
- 站点服务器: 内网 IP / SSH 别名：myhost
- 对象存储: bucket=*** / 公开域=*** / token 见 .secrets/r2.txt

## 工作流闭环
- 写文章 → drafts/{cat}/{date}/{slug}.md（draft=false）
- 同步 NAS → sync-to-nas.sh
- 发布 → ssh user@myhost "..."
- 配图 → r2-upload.sh 上传后嵌入

## 风格铁律
- 长文 ≥ 1 万字
- 5 段式：痛点→原理→配置→实战→踩坑
- 必含表格 + 代码块 + 互链前作

## 已踩坑
- R2 token 不要 List 权限：rclone lsd 会 403
- key 不要中文：CF 自定义域 URL 编码翻车

安全提醒：MEMORY.md 这种文件只应在本地存在，不要把真实 IP / 账号 / bucket 名贴进对外文章。我曾经差点把内网 IP 写进发布稿里，幸好 review 时发现——示例和真实凭据永远要分开。

判断哪些信息该写进 MEMORY.md：

• ✅ 你下次还会用到的（凭据、IP、路径、版本）
• ✅ 你的口味偏好（这个项目用 TypeScript 不要 JavaScript）
• ✅ 已经踩过的坑（避免重复掉同一个坑）
• ❌ 一次性的（今天某个 bug 的具体错误码）
• ❌ 客气话和过程性确认（“好的”、“我来做”）
• ❌ 跟当前正在做的事相关的临时上下文

每日的 memory/YYYY-MM-DD.md 模板：

# 2026-05-22

## 做了什么
- 选了今天的题目：Claude Code Token 优化（#6）
- 写了 5400 字的初稿
- 重构了大纲，改成痛点驱动

## 学到什么
- ...

## 没解决的问题
- ...

## 给未来的自己
- ...

把这套养起来，每个新会话开场只要 read 三五个 markdown 就有完整上下文。比"会话连续聊到死"既省钱，又记得清楚。

更妙的是——这些 markdown 用人类也能读。哪天 AI 服务挂了，你的笔记还在；哪天换 AI 工具，迁移成本几乎为零。钱省了，护城河还顺手挖了。

招式七：模型梯度路由——小事 Haiku，大事 Opus（主打 全局）

最后一招最简单也最容易被忽略：别永远用最贵的那个。

Anthropic 现在三档：Haiku / Sonnet / Opus。价格大致是 1 : 5 : 25。但写代码的日常 80% 是琐事——重命名变量、补 TypeScript 类型、写一段简单 SQL，Haiku 完全够用，反应还更快。

OpenClaw 支持 router 配置（我现在用的 9router/article-pool 就是个例子），可以根据任务复杂度自动选模型：

# 简化的 router 思路
小任务 (rename, format, simple regex)   → haiku
中等任务 (写函数、改组件、debug)         → sonnet
重活 (架构设计、长文档、复杂重构)        → opus

也可以手动切：复杂问题前 /model opus，搞完切回 /model haiku。但我前面说过——频繁手切会破坏 cache，所以更建议用 router 自动化。

我自己的口诀：

“如果这件事我能在 30 秒口头说清需求，就用 Haiku；如果需要画图才能讲明白，才上 Opus。”

具体决策树：

最后那条特别有用——与其在 Sonnet 上反复追问 5 次，不如直接升 Opus 一次问完。5 次 Sonnet 的钱常常超过 1 次 Opus，时间还更长。

这条单看节省比例不大（也许 15-20%），但跟前面 6 招叠加，乘出来就很可观。

踩坑实录

省钱不是没代价，下面这些坑我每个都踩过，写出来希望你别再踩。

坑一：SKILL.md 拆得太碎，AI 找不到入口

我有一阵子把 SKILL.md 砍到 10 行，结果 Claude 经常不知道该 read 哪个 detail 文件，干脆放弃用 Skill 直接硬猜。后来发现：SKILL.md 至少要交代清楚"我有这些子文档，分别管什么"——把它当目录页，不是封面。30~50 行左右是甜点。

坑二：sub-agent isolated 模式忘记传上下文

isolated 子 agent 不会自动看到主会话的任何东西。一次让它"按之前讨论的风格写"，它一脸懵——“之前"是哪个之前？后来我都在 task 描述里把必要前提写明白，或者让它先 read 一个事先准备的 brief 文件。

坑三：/clear 太频繁，反而 cache 失效

刚学会这招那阵每聊 10 句就 /clear，结果 cache 还没建立稳定就被打掉了，付了一堆 miss。/clear 是任务切换时用，不是焦虑性按钮。同一类任务一直聊就是它该干的事，让 cache 充分发挥。

坑四：把 MEMORY.md 写成日记

最早我啥都往 MEMORY 里塞——某天的心情、某次跟同事吵架的复盘、随手记的灵感。后来发现 AI 每次开场 read 都要算钱，几个月后 MEMORY 涨到 8000 字，开场费倒退到改造前。MEMORY.md 不是日记，是字典——只放查得到答案的事实。情感和过程移到日记 memory/YYYY-MM-DD.md，AI 不主动读。

坑五：用 sub-agent 跑死循环

让 sub-agent 自动批量改文件，结果它改完一轮发现还有问题，又起一轮，又起一轮——最后跑了 12 轮，账单一晚上炸了 $30。后来给所有 sub-agent task 加上"最多重试 2 次，超过就 abort 报告人类”。自动化要给 AI 装刹车，刹车比油门重要。

坑六：模型一升一降 cache 全废

/model opus 问一个问题，得到答案后 /model haiku 继续，发现 input 价格异常——因为切了 model，前面 cache 全部失效，重新 miss 一次。解决方案：复杂问题在新会话里 opus 一次性解决，结果记到笔记里，主会话保持 haiku 不切。

Case Study：写这篇文章总共烧了多少 Token？

光讲方法论太抽象，我把写这篇文章的全过程拉出来给你看一眼实际数字。整篇文章大约 8000 字，从选题到成稿走了 4 个小时。如果用旧姿势会烧多少？用新姿势又烧了多少？

旧姿势模拟（按我以前的习惯估）：

按 Sonnet 现价 input $3 / M token 算，约 $0.72。光是写一篇文章。

新姿势实际（这次实测）：

按同样 Sonnet 价格，约 $0.07。一篇文章节省了 $0.65 = 90% 以上。

这只是一篇文章。如果你每天写代码、改 bug、调架构，按一天 8 个类似规模的“会话单元”算，月底差距能拉到 $150 以上。

更让我意外的是——新姿势写出来的内容质量更高。因为 sub-agent 出来的素材是结构化的（表格、要点、对比），主会话拿到的输入更清晰，反而推理更准。省钱顺手把质量也提了，这种好事不多。

横向对比：Cursor / Aider / Codeium 的 Token 模型

有人问我：换工具能不能直接解决省钱问题？我把市面主流的几个 AI 编程工具拉出来横向对比，结论是——省钱 70% 靠姿势，30% 靠工具。

几个观察：

1. 订阅制 ≠ 真便宜。Cursor 月费 $20 看着划算，重度用户两周就能把 fast premium 额度耗光，超额按次跟直接走 API 没本质区别。
2. 看不到账单的工具最危险。Copilot 这种月费固定的反而最省心，但能力上限低，复杂任务还得回到 Claude Code。
3. 真正决定开销的是你怎么用。同一份 Cursor 订阅，A 用户烧到上限 B 用户用一半——区别全在前面那 7 招里讲的姿势。

所以建议不是“换工具”，而是留在你最顺手的工具里把姿势磨好。换工具的成本（学习 + 重新配置）通常比省下的 token 钱还高。

如果你真要“轻量化”，我的推荐组合：

• 日常 80% 时间：Copilot（月费固定）补全代码
• 复杂思考的 20%：Claude Code 调用一次，按上面 7 招姿势用
• 零碎查询：直接 Web 端 Claude / ChatGPT，不算 API

这套组合下来一个月不超过 $30，能干 80% 的活。

进阶 Helper 工具集

光说不练假把式。把我抠出来的几个 helper 脚本贴在这里，复制即用。

1. ~/.bashrc 里的 token 友好工具集：

# 大文件预览（前 50 + 后 50）
peek() {
  local f="$1"
  local lines=$(wc -l < "$f")
  if [ "$lines" -gt 500 ]; then
    echo "==== first 50 ====" && head -50 "$f"
    echo "==== last 50 ====" && tail -50 "$f"
    echo "==== total: $lines lines ===="
  else
    cat "$f"
  fi
}

# 项目结构精简显示
tree2() {
  tree -L 2 -I 'node_modules|.git|dist|build|.next|target|.venv' "$@"
}

# git 改动概览（不出全 diff）
gdiff() {
  git diff --stat "$@"
  echo "---"
  echo "用 'git diff <file>' 看具体某个文件"
}

# 错误日志聚焦
errlog() {
  tail -500 "$1" | grep -iE "error|fail|exception|fatal" | tail -30
}

# JSON 取样
jsample() {
  jq -c '. as $r | if type=="array" then .[0:3] else . end' "$1"
}

# 进程/磁盘快速 top
pstop() {
  ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%cpu | head -15
}

dutop() {
  du -h --max-depth=1 "${1:-.}" 2>/dev/null | sort -rh | head -15
}

把这一坨贴进 ~/.bashrc，然后跟 AI 说“用 peek / tree2 / gdiff 看”，每次都能省一大截 token。

2. SKILL.md 模板（精简版）：

# <skill-name>

## When to use
用户提到 <关键词1>、<关键词2>、<场景描述> 时激活。

## Quick path
1. read DETAILED.md 看完整步骤
2. 主入口命令: <command>
3. 出错先看 TROUBLESHOOT.md

## 关键路径
- 配置文件: <path>
- 日志位置: <path>

超过这个长度就该想想“是不是该下沉到 DETAILED.md”。

3. sub-agent task 描述模板：

[目标] <一句话说清要干什么>
[输入] <文件路径 / 数据 / 上下文 brief 文档>
[期望输出] <格式化要求：markdown 表格 / JSON / 几行总结>
[禁忌]
  - 不要返回原始数据
  - 最多重试 2 次，失败就 abort 报告
  - 不要污染主任务上下文

4. router 配置思路（伪代码）：

# 路由规则
if task.type in ["format", "rename", "simple_regex"]:
    return "haiku"
elif task.tokens_estimate > 50000 or "architecture" in task.tags:
    return "opus"
else:
    return "sonnet"

实际部署时可以根据自己的工作流调整阈值——重点是让模型选择自动化，把心智负担拿掉。

一个真实踩坑：我是怎么发现自己一晚烧了 $30 的

这个故事必须讲。它是我整套省钱方法论的导火索，比账单本身更让我记忆深刻。

那是个周五晚上，我在调一个 LXC 容器的网络问题——OpenClaw 在 PVE 上跑得好好的，迁移到一个新节点后死活连不上 Anthropic API。我打开 Claude Code 想让它帮我看，输入大致是这样的：

请帮我分析 LXC 容器内的网络问题，curl https://api.anthropic.com 总是 timeout

AI 让我贴一些信息进去。我贴心地一口气把以下东西都甩了过去：

• ip a 输出（容器 + 主机）
• iptables -L -nv 全文（300+ 行）
• journalctl -u openclaw --since="2 hours ago"（5000 行）
• PVE 主机的 /etc/network/interfaces
• 还有相关 LXC 配置文件

第一轮没解决。AI 让我再跑几个测试。我又贴了 tcpdump 抓包结果（4000+ 行）和 dmesg | tail -1000。第二轮也没解决——但 input token 已经偷偷飙到 18 万。

第三轮我急了，干脆把整个 PVE 节点的 /var/log/syslog 也贴了进去——3 万行，一次 47 万 input token，单条对话 $1.41。

来回折腾到凌晨两点，问题终于定位到是 keyctl 的 capability 没开。整夜对话总 input 大约 820 万 token。按 Sonnet input 价格算，光那一晚账单 $24.6，加上零星 output 和之后几次重启验证，那一晚总共烧了 $30 出头。

第二天早上我盯着 usage 仪表盘看了很久。问题本身只是加一行 capability 配置——五个字符级别的修复，我却为它支付了一顿火锅的钱。

复盘下来错在哪？

1. 没用 sub-agent——日志和抓包应该让 isolated 子任务先做摘要，主会话只接结论。
2. 没截断输出——dmesg | tail -1000 完全可以变成 dmesg | tail -100 | grep -iE "error|deny"。
3. 会话没切——从凌晨 0 点到 2 点同一个会话，每条新消息都拖着前面的全部历史。
4. 没用 cache——焦虑下我反复 /model opus /model sonnet 切换，cache 全部击穿。
5. 没让 AI 用工具命令——它本可以自己 grep 出关键行而不是读全文，但我没要求它这么做。

那一晚之后我开始系统性整理这套方法论。这篇文章里讲的每一招，背后都站着一个具体的 $30 那一晚——区别只是疼到什么程度。

Token 监控：账单飙之前怎么提前发现

省钱不能等月底看账单。我现在的工作流里加了一套轻量监控，让我能在事情失控之前察觉到。

1. 每天看一次 cache 命中率

登 Anthropic Console，看 cache_read_input_tokens 占 total_input_tokens 的比例。健康状态是 70%+。如果某天突然掉到 30%——说明你那天做了什么破坏 cache 的事，最常见的是：

• 改了 SKILL.md / system prompt 后没攒批，反复重启验证
• 频繁手动切 model
• 用了一个新插件，它在背后乱发 API

2. 设一条简易超额预警

Anthropic Console 里能设 spend cap。我把 daily 上限设在 $3——超过就发邮件提醒。这条软限很关键，让我能在烧到 $30 之前停下来想一想发生了什么。

# 类似思路也可以本地实现
# 用 cron 每天跑一次 usage 拉取脚本
0 22 * * * /home/user/scripts/anthropic-daily-usage.sh

脚本内容大致是用 Anthropic API 拿当日 usage，超过阈值就 ping 飞书 / 邮件。代码不长，几十行 Python 搞定。

3. 周复盘：每周一翻账单

每周一花 5 分钟，对照上周 7 天的 daily token 看趋势：

• 哪天烧得最猛？为什么？是高强度工作日，还是有个失控的 sub-agent？
• input/output 比例正常吗？正常应在 30:1 左右，比例突涨说明上下文堆积
• cache 命中率有没有下降趋势？连续下滑 3 天就要 review SKILL.md

这套监控看起来繁琐，真正做起来一周不超过 30 分钟——但能让你的账单永远不会惊喜。

比起亡羊补牢，养一个反馈闭环才是长期省钱的根。

新手 30 天养成路线

如果你是 Claude Code 新人，下面这套节奏照搬即可——我把这 7 招按“上手成本”和“产生收益的时间”做了排序，每周做哪几件事一目了然。

Day 1~3：建立基础纪律（这 3 天就能砍掉 30% 账单）

• 把 /clear 写到任务切换的肌肉记忆里——每换一类问题就清。
• ~/.bashrc 贴 helper 函数集（peek / tree2 / errlog），让所有“读文件”动作自动截断。
• 在 system prompt 或 SOUL 文件里加一条：“读文件前先 wc -l，超过 500 行用 head/tail”。

Day 4~7：cache 优化（再砍 20%）

• 检查现有 SKILL.md，超过 60 行的全部拆成两层结构。
• 改用 router 配置（如 OpenClaw 的 9router），别手动切 model。
• 关掉那些“主动询问 AI”的 IDE 插件——别让它在背后偷偷烧钱。

Day 8~14:sub-agent 隔离（再砍 15%）

• 识别哪些活适合外包:翻日志、批量改文件、跑测试、读文档。
• 用 isolated 模式启动 sub-agent，task 描述用四行模板（目标/输入/输出/禁忌）。
• 给所有 sub-agent 加“最多重试 2 次”的刹车。

Day 15~30:知识库长效化（开始产生复利）

• 建立 MEMORY.md，把凭据、IP、版本、决策、踩坑沉淀进去（≤3000 字）。
• 每天写 memory/YYYY-MM-DD.md，作为可 grep 的日记。
• 把重复 3 次以上的方法论提炼成 SKILL。

按这条路线走，第二个月开始账单稳定在第一个月的 1/3~1/4。这不是“省钱”，是把 AI 编程的工作姿势整体提升了一个维度——省钱只是结果，效率和清晰度才是真正的副产品。

如果你已经是老用户，账单还在飙——往回看你属于哪一阶段。多数人卡在 Day 4~7（cache 优化没做），少数人卡在 Day 15+（不肯写文件，依赖会话历史）。对症下药，不要全套照搬。

30 天复盘：账单怎么从 $214 走到 $40

月度对比：从 $214 → $122（前一周 $52 ×4 不到，因为后面在改）→ 月末稳定在 $40 左右的均速。新一个月开了大半，目前还在 $30 上下。

砍掉的 $174 里，最大头的是招式三（/clear 纪律）和招式六（本地知识库）——这两条本质上都在治 context 堆积。这跟我前面那张吞金兽表完全对得上：context 堆积是最大那只兽，对症下药效果最猛。

收尾：把 7 招按性价比排个序

复盘下来一句话：Claude Code 不贵，是你跟它的相处姿势贵。

把"无意识的输入"治住，把"重活外包"养成习惯，把"高频开场"挪到 cache 里——剩下花的，全是真正解决问题的钱。这种钱，花起来不肉疼。

更深一层的体会：省 token 的过程意外地让我代码写得更好了。被迫精简 prompt → 思路更清晰；被迫让 sub-agent 隔离干活 → 任务边界更清楚；被迫用 markdown 沉淀知识 → 自己也想问题更系统。省下的不只是钱，还有"模糊的工作姿势"。

下一篇我打算写"OpenCode 9.4 万 stars 是不是真的能替代 Claude Code"，会做一周深度对比实测。如果你也在纠结要不要换，可以等等。

FAQ

Q1：我才入门 Claude Code，没必要这么早抠 token 吧？

恰恰相反——早期养成的姿势会决定你后面三个月的账单。等月烧 $200 才想起来省，前面那 $200 已经付了，习惯也已经长歪了。我建议从第一天就让 /clear 进肌肉记忆。

Q2：sub-agent 是不是会让响应变慢？

是的，多一层调度会慢 5~15 秒。但分清场景——主会话你需要快速反馈，sub-agent 干的活通常你也可以喝口水。慢一点不影响节奏，反而强迫你别“焦虑性追问”。

Q3：MEMORY.md 写多了 AI 是不是会混淆？

会。所以红线是总长不超过 3000 中文字，分章节组织，每章节有清晰标题。AI 读 MEMORY 是为了找“事实”，不是读小说，结构化最重要。

Q4：cache 命中率怎么查？

登 Anthropic Console → Usage → 拉时间段。看 cache_read_input_tokens / 总 input token。我自己的目标是 70% 以上，超过 80% 优秀，低于 50% 说明姿势出了问题。

Q5：写一个 Skill 划算还是用普通 prompt 划算？

判断标准：这个任务一周内会重复 3 次以上吗？ 是 → 写 Skill；否 → 当次解决。Skill 的初始投入（写 + 测）大约 30 分钟，能 amortize 的前提是有重复使用。

Q6：长文档怎么塞给 AI 才不烧钱？

几招组合拳：

1. 文档放 NAS / 本地，不直接贴会话
2. 给 AI 路径，让它按需 read 片段
3. 大文档先用工具命令(grep / awk)缩到几屏
4. 实在要全部读，用 sub-agent isolated 模式读，主会话只接结论

Q7：团队场景这套还适用吗？

大部分适用，但有两点要调整：

1. MEMORY.md 要分公私——团队共享的放 repo 里，个人偏好放本地
2. Skill 仓库要 review——别让队友写的 SKILL.md 失控膨胀，开个 30 行硬性上限

进阶话题：什么时候省钱反而亏了

这套方法论用了两个月之后，我发现一个反直觉的现象——有些场景下“省 token”反而是亏的。技术决策永远要看大局，省 $5 token 但花按1 小时的活，本质是在亏钱。

下面这几种场景，我现在已经放弃节俭，老老实实让 AI 多吃 token：

场景一：架构设计 / 关键决策

选一个数据库、定一个 API 协议、决定要不要重构——这种事一旦做错，后面要花几十小时去填坑。这时候我宁愿让 Claude 把项目里所有相关代码全读一遍，给出深度建议。多花 $2 token 但避免一周的弯路，这是 ROI 最高的钱。

场景二：调一个一直找不到的 bug

如果某个 bug 我自己已经搜了 30 分钟还没头绪，与其继续抠门让 AI 看片段，不如打开“全套上下文”模式——让它读相关日志、代码、配置全部。一次烧 $1 但 5 分钟解决，比“省着用”反复来回半天划算多了。

场景三：写一份需要发出去的重要文档

这种场合质量优先。让 AI 把背景资料、相关文档、参考案例全部读全再写，比一段一段挤好得多。最终交付物的“分量感”是 token 堆出来的——该花的别省。

场景四：团队协作场景

如果是团队共享 Claude，节俭过头会让队友觉得“AI 这工具不好用”——比如有人问个简单问题但因为 SKILL.md 拆得太抽象 AI 答不上。这时候稍微“丰满”一点反而是必要的，便利性跟成本要平衡。

判断“该不该省”的简单标准：

这个 token 节省下来，能换回多少倍的时间或决策质量？

如果换不回来，省得再狠也是负 ROI。省钱不是目的，把钱花在刀刃上才是。

我的实际工作流：一天的 token 是怎么分配的

讲完原理和招式，给个具体的工作流闭环看看。这是我最近一周的“典型一天”——总 token 约 60k，账单约 $0.4。

08:30  开机，新会话
  - 主会话 read MEMORY.md（~800 token）
  - read 今日 memory/2026-05-22.md（~500 token）
  - 准备好今日 todolist
  cost: ~$0.005

09:00-11:00  写文章（这篇）
  - 主会话短对话定大纲
  - 起一个 isolated sub-agent 翻 NAS 历史选题
  - 主会话基于 sub-agent 总结撰写
  - 中途无 /clear
  cost: ~$0.10

11:00  /clear，切到运维任务
  - 看监控发现某个服务 CPU 高
  - peek 日志而不是 cat
  - 用 sub-agent 跑诊断
  cost: ~$0.05

13:00-15:00  /clear，写代码（PR review）
  - 短文件用 read，长文件让 AI 用 grep
  - 用 git diff --stat 而不是 git diff
  cost: ~$0.08

16:00  /clear，最后一个会话——回 issue
  - Haiku 模型即可
  cost: ~$0.02

21:00  /clear，做今日 memory 总结
  - 写 memory/2026-05-22.md
  - 更新 MEMORY.md（如有重要决策）
  cost: ~$0.01

Daily total: ~60k input + 12k output ≈ $0.40

注意几个关键点：

1. 每个任务边界都 /clear——5 次 clear，5 个干净的会话起点
2. sub-agent 做了 3 次重活——主会话从未消化过原始日志或长文档
3. 模型梯度路由自动跑——简单回 issue 走 haiku，写文章走 sonnet
4. MEMORY.md 每天 read 一次但只有 800 token——成本极低，价值极高

按这个节奏，月度账单稳定在 $12 上下（工作日 22 天 × $0.4 + 杂项 $3）。从我刚开始的 $214 到现在，节省比例 94%——而且产出质量没降，反而因为流程更清晰，错误率比以前低。

对号入座：你属于哪种用户画像

这 7 招不是人人都要全上。根据你的使用强度和场景，优先级不同。我把身边朋友拉出来分成三类，看你是哪一种。

画像一：偶尔选手（月账单 < $30）

特征：周末需要才开 Claude，主要帮个人项目。年烧不到 $360。

优先看：招式三（/clear 纪律）+ 招式五（工具输出截断）。这两招上手成本低，产出收益快，能把你从 $30 拉到 $15。SKILL.md、sub-agent、MEMORY.md 这些重投入的招式抑迟上——你的使用量达不到 amortize 阈值。

一句话：微调纪律即可，别上架构。

画像二：重度玩家（月账单 $30~$200）

特征：每天都开，写代码 + 写文档 + 运维全报。我自己之前在这个档位。

优先看：全部 7 招都要上，但需要 1~2 个月分阶段部署。按前面“新手 30 天路线”走。最高 ROI 是招式三 + 招式六（本地知识库），这两招加上能决定你是 $50 月 还是 $20 月。

一句话：他们说的都是针对你说的。

画像三：专业选手（月账单 > $200）

特征：全职靠 AI 生产力、运营 SaaS、或代客户跑项目。

优先看：这7 招只是入门。你还得上：

• API 级别的 prompt cache + batch 启用
• 多账号 负载均衡（有些账号能拿到不同价位）
• 自建 router 服务控制模型选择
• 部署 token usage 实时仪表盘（Grafana + Anthropic Usage API）
• 考虑 Claude API 与 Anthropic 的 enterprise plan 谈价

一句话：这个量级该考虑能不能将本文 7 招变成产品功能赖他们付费。

看完这三个画像。如果你是画像一，别看后面了——招式三和五够你用三年。如果你是画像三，本文只是起点，你需要的东西在 Anthropic Enterprise 文档里。

多数人是画像二，也是本文的目标受众。

隐性烧 token 黑洞

讲了 7 招显式技巧，最后再补一组隐性陷阱——账单上看不出哪条是凶手，但累起来可能烧得猛。

陷阱一：MCP 服务器返回大对象

MCP（Model Context Protocol）让 AI 直接调外部 API。但很多 MCP 实现把整个响应原封不动塞回上下文。比如调一个 “列出 GitHub 所有 issue” 的 MCP，一口气吐 200 个完整 JSON——你以为只问了一句话，背后吃了 30k token。

解法：MCP 工具自带 pagination 和 field filter。配置时主动限制返回字段，比如 GitHub API 只要 title, number, state 三列，省 80% 字段。

陷阱二：自动推送文件树

有些 IDE 集成在每条消息前自动把当前 workspace 文件树喂进去——5000 个文件就是 5000 行 path，每条消息都付一次。检查你的 IDE 配置，关掉这种贴心行为。

陷阱三：Markdown 表格里的对齐空格

一个看起来美观的 markdown 表格可能比同等内容的 CSV 多 40% token。让 AI 看 CSV 或 minified markdown，让人类看 pretty 版——分开存。

陷阱四：示例代码塞太多上下文

你贴一段代码让 AI 看，习惯把整个文件 1000 行都贴上。其实 AI 真正需要的是函数所在的那 50 行 + import 列表。精确截取比全套保险更省。

陷阱五：无意义的 “是的请继续”

会话里这种短回复，每次都让 AI 把前面所有上下文重读一遍。如果只是确认，用 emoji 回复或直接跳到下一个具体问题。

陷阱六：忘记关掉的 streaming

有些环境下 streaming 模式让 AI 边想边输出。如果你在做批量处理任务（不需要看过程），关掉 streaming 改用 batch 模式，按累积调用收费会便宜 10~20%。

这些陷阱单独看不大，但累加起来可能占你账单的 20~30%。月底如果账单异常，照这份清单逐个排查，多半能找到漏点。

写在最后

这套省钱姿势不是 Anthropic 教我的，也没在哪本书上看到——是 $214 那张账单逼出来的。技术上没什么“魔法”，全是工程纪律：拒绝无意识输入、把重活分包、给 cache 让路、用文件代替记忆。

说到底，AI 编程工具的“贵”，90% 是因为我们把它当成了一个永远耐心的朋友——它不嫌你啰嗦，它真的会全部读完，但每个字都在收钱。学会节制不是“对 AI 抠门”，而是把它放回工具的位置：精准下达指令，让它把活干漂亮，不闲聊、不情绪化、不“以防万一”。

这种工作姿势养成之后，最妙的副作用是——就算哪天换 AI 工具，你的整套笔记体系、Skill 仓库、helper 函数都还在。AI 模型会迭代，工具会更换，但你沉淀下来的“跟智能体怎么协作”的方法论，是你自己的护城河。

如果这篇文章帮你砍了哪怕一杯咖啡的钱，记得回来留个言告诉我——我喜欢看读者晒账单截图，比看自己的还开心。