AI 编程的 token 到底花在哪，怎么省下来

0030 秒速览：三句话，和一张"按你的处境查"的索引

读完这一篇，你能做到三件事：打开一个会话就能看懂它的账单、说清自己的钱到底花在哪一类请求上、并且能用三四个改动把每月的 token 花掉一大块——不需要换工具，也不需要写代码。

按你的处境，直接看这一节

一条能立刻执行的三步路径

01token 到底是什么，钱又按什么算

先把三个词钉死：token（令牌）、上下文窗口（context window）、计费单位。这三个词你在别处都见过，但九成的人第一次的理解是错的——而账单就是按它们算的。

token 不是"字"，是模型切出来的小块

大语言模型不按"字"读文本。它在读之前，先把你给的内容切成一个个小块，每块给一个编号，然后按块处理——这一小块就叫一个 token（令牌）。它可能是一个完整单词、半个单词、一个标点、一个汉字，也可能只是几个字母。模型和计费都只认这些块，不认你眼里的"字"。

所以"这段文字值多少钱"这个问题，准确的说法是"这段文字会被切成多少个 token"。而切法由模型自己的一套规则决定（这套规则叫分词器，tokenizer），不同模型切法不同，同一句话切出来的块数就不一样。

这一点现在比过去更要紧：官方在定价页和 token 计数页都写明了，Claude 4.7 及之后的模型换用了更新的分词器，同样一段文字会比旧模型多产出大约 30% 的 token——所以你不能拿旧模型上量出来的数字去估新模型的账单。

为什么"1 个汉字 ≈ 几个 token"这个问题没有统一答案

"token 等于多少字"这类系数只在同一家厂商的同一代模型内部近似成立。三家的官方口径互相都不一样：

上下文窗口：一次能"记得"多少，也决定上限

上下文窗口（context window）是单次请求里能装下的 token 总量上限——它装的是"这次要一起送进去的全部内容"，包括系统提示、项目说明文件、历史对话、工具说明和你这句新指令。它不是"记忆容量"，更不是"该塞满的地方"：装得越满，每一轮都越贵。

当前官方口径（来自上下文窗口文档）：

另外记住单次输出的上限：1M 窗口那批模型单次最多生成 128k token。它会约束你"让它一口气写完整本书"这类要求的可行性，也提醒你输出按 5 倍价计费。

一次请求的账单公式：三种价，不是一个价

当你按量付费（走 API 或云厂商）时，一笔请求的费用不是一个单价乘一个数量，而是四笔账相加：

费用 ≈ 新读入的 token × 输入单价
     + 从缓存读到的 token × 缓存读取单价（通常是输入单价的 0.1 倍）
     + 写进缓存的 token × 缓存写入单价（约输入单价的 1.25 或 2 倍，一次性）
     + 本轮新生成的 token × 输出单价（通常是输入单价的 5 倍）

这四行的相对倍数（0.1 倍、1.25 倍、5 倍）不是某一家厂商的独家规则：Anthropic 与 OpenAI 两家官方的定价页给的都是同一组倍数，差的是各家模型的绝对单价。这个事实直接决定了你的优化顺序——"少写"比"少读"值钱，而"让重复的部分命中缓存"比两者都值钱。

02为什么"就改一个标点"也能贵

先给一个公允的结论：不是工具在偷你的钱，是"AI 编程"这种任务形态天生就耗 token。普通聊天和编程助手的花钱方式不是程度差别，是形状差别——下面这张流程对比就是全部的根源。

原因一：每一轮都要重发整段上下文（占大头）

官方成本文档的原话是：Claude Code（一款在终端里跑的 AI 编程助手，本文以它为例给具体命令）"每次请求都会发送你的完整对话"（sends your full conversation with every request），并且每次它调用工具，都会再发一笔请求、把那批工具结果一起带上。放到第 50 步，这一条请求里就装着前 49 步的所有文件内容与命令输出——哪怕你这次只问了一个标点。

这里最容易产生的误解是"我没写多少字，怎么会贵"。因为你写的字根本不是主菜：你这次的指令往往是一笔请求里最小的一块。

原因二：工具结果是最肥的一块

让 AI 读一个 3000 行的文件、跑一次全量测试、贴一段 10 万行的日志——这些工具结果会原样进入上下文，一次就是几万到几十万 token，而且更糟的是它会一直躺在那里，在此后每一轮被重新发送一遍。这就是"读一次大文件"的代价远大于"读一次"的原因。

原因三：输出比输入贵约 5 倍

各档模型的输出单价约为输入单价的 5 倍（11 有当前单价表）。所以让 AI"多写"——大段解释、把整份文件重贴一遍、长篇试错——比让它"多读"更烧钱。这也解释了一个反直觉现象：让它"用大白话把这段代码再讲一遍"是很贵的要求，因为那整段都是输出。

原因四：思考也在花钱

新一代模型默认"先思考再动手"，而官方明确：思考产生的 token 按输出价计费（因为性质上就是模型生成的内容），默认的思考预算可能达到每次请求数万 token。这不是玄学，是可以调的档位（11）。

官方还给了一组让人清醒的企业数据：平均成本约为每位开发者每个活跃日 13 美元、每月 150–250 美元，而 90% 的用户每个活跃日低于 30 美元。这个数字的意义不是"你也该花这么多"，而是给你一个量级参照：如果你一天花掉的是这个数的十倍，那不是"AI 太贵"，是某几个习惯出了问题。

03一次请求的钱花在哪：输入、输出、缓存三种价

把"一笔请求"拆开看。你以为你给 AI 的输入只有最后那句话，实际发送过去的是下面五块拼起来的一大坨——理解这个拼法，后面所有省钱技巧才有落点。

为什么这个顺序很重要

因为这五块是按顺序拼成一条前缀的，而缓存判断的正是"前缀是不是和上次逐字节相同"。顺序决定了失效范围：改了工具定义，后面的系统提示、项目记忆、历史对话全部重算；只改了历史里的一句话，就只影响那之后的部分（10 有完整表）。

三种价，各自对应哪一块

另外两个"隐性消耗"：自动压缩与工具往返

自动压缩（auto-compact）：会话逼近上下文窗口上限时，工具会把旧历史总结成一段摘要腾地方。这次总结本身就是一笔很大的请求（等于把整个会话读一遍、再写一遍），而且之后的每一轮都会带着这份摘要继续膨胀。它是救命机制，不是省钱机制。

工具往返放大：AI 每"读一次文件 / 跑一次命令 / 查一次网页"，就要发一笔携带全上下文的新请求。一个看起来简单的重构，背后可能是 30–80 次工具调用，每次都是全量输入。

04最小例子：读懂一次会话的账单

理论到此为止。这一节只做一件事：把一段真实的用量输出逐行翻译成人话，再手算一遍钱。看懂这一个例子，你就超过大多数只会埋头提问的用户了。

第一步：敲 /usage，看它到底打印了什么

各家的用量命令名字不同（Claude Code 是 /usage，也有工具用 /context 一类命令，插件多在状态栏显示）。下面这段是官方成本文档给出的示例输出，我原样抄下来——它已经把本文所有概念装进去了：

Total cost:            $0.55
Total duration (API):  6m 20s
Total duration (wall): 6h 33m 10s
Total code changes:    0 lines added, 0 lines removed
Usage by model:
    claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)
Prompt cache (main): 14 requests · 91% of input tokens from cache · warm (1h TTL, last activity 40s ago)

第二步：逐行翻译

第三步：手算一遍，一次普通会话大概多少钱

用最简单的方法粗估：一次"改个小功能"的会话，输入总量常在 10 万～40 万 token（其中大部分是重复历史），输出在几千到几万 token。按 Claude Sonnet 5 当前单价（输入 $2/百万、输出 $10/百万、缓存读取 $0.20/百万、5 分钟缓存写入 $2.50/百万）毛估，假设其中 25 万 token 命中缓存：

输入（未命中部分）  5 万 token × $2/百万        ≈ $0.10
输入（命中缓存）   25 万 token × $0.20/百万     ≈ $0.05   ← 缓存把它几乎抹平
输出               2 万 token × $10/百万        ≈ $0.20
缓存写入           5 万 token × $2.50/百万      ≈ $0.13   ← 一次性，只在建缓存那轮交
──────────────────────────────────────────────────────
一次普通会话合计                              ≈ $0.48

这个量级意味着两件事：一个重度按量用户每天跑 20 个会话，月账单很容易到三位数美元（这正是"每人每月 150–250 美元"的来源）；反过来，把"每个会话更短、更少反复、缓存命中率更高"做到位，省下来的钱是实打实的。你可以把上面四个数字换成你自己的会话量级，再乘一下——这就是你自己的账单模型。

第四步：现在就做，只看三个数字

打开你正在用的助手，运行它的用量命令，只看三件事：① input 里"新读"和"缓存读"的比例；② output 有多大；③ 会话已经多少 token。看懂这三项，你就已经知道该往哪个杠杆上使劲了。

05先记账：在不花钱的地方看钱

省钱的第二步永远是先度量，再优化。凭感觉"省"只会省到不该省的地方（比如为了少几毛钱，让 AI 少读一个必要文件，结果返工三轮）。下面几个动作，任何助手都该有，命令以 Claude Code 为例。

几个地方看用量，各有各的用处

用"行为指标"找病根，而不是只盯总额

账单里有些信号能直接指向病因。Claude Code 的用量面板还会主动标出占你近期用量 10% 以上的行为，并各给一条建议：

用量算在谁头上：一个容易混淆的点

官方提醒过，这类统计是"本机视角"：你在 A 电脑开的会话，在 B 电脑的面板里看不到。另外一些消耗发生在你根本没提问的时候（后台摘要任务、跨会话投递的消息、到点就响的定时任务、以及还没收工的团队助手），官方称这类后台开销通常每个会话低于 0.04 美元，但积少成多。所以看账单别只盯着主线会话那一个数字。

06你是哪种付费用户——这决定你该"省什么"

同一个动作（比如"让它重跑一遍测试"），对不同付费方式的人含义完全不同。先把身份对号入座，否则你会用错力气：包月用户在省额度，按量用户才在省真金白银。

三种身份，三种"省"

包月用户最容易踩的误区

额度用尽之后会发生什么

以 Claude 的 Pro / Max 为例：额度用尽会暂时被限流，等窗口重置后恢复；如果开启了"加购用量"（usage credits，也就是额外买一份按量的量），超出部分会按 token 继续计费——这通常是"这个月怎么突然多扣钱了"的原因。官方还允许订阅用户手动设置月度消费上限，避免彻底失控。

07杠杆一：会话卫生——最被低估的省钱习惯

回到 03 那张拼图表：你的每一笔请求，都背着从开场到现在的全部历史。所以"一个会话聊得越久、越杂"，每一轮的固定成本就越高——哪怕你只是问一句"现在几点了"。会话卫生，就是管理这条越滚越大的历史。

几种"清理动作"，花费完全不同

/clear 和 /compact 到底怎么选

一条判断口诀：下一句要问的事，需要它记得上一个任务吗？不需要，就 /clear。这个两秒的判断，是本文性价比最高的一个动作。

压缩前告诉它"该保什么"

/compact 可以带一句话指令，直接决定摘要里留下什么。别默认让它自己挑：

/compact 请保留：复现步骤、已排除的假设、涉及的文件清单、最近的测试命令与改动

更好的做法是把这条偏好固化到项目里，让整个项目每次压缩都生效。官方给的写法是在项目根目录的记忆文件里加一段：

# Compact instructions
When you are using compact, please focus on test output and code changes

会话卫生的三条进阶配方

• 阶段性完成就果断清：宁可每半小时 /clear 开一个小而新的会话，也别开一个马拉松会话硬扛到晚上。
• 别反复续同一个巨会话：官方对长会话提供"从摘要续聊"的选项，就是为了让你别再把整段巨历史背回来。能用摘要续，就别全量续。
• 清之前先起名：/rename 是免费的，它让"清掉"不再意味着"丢掉"——这是让会话卫生这个习惯能坚持下去的关键一步。

08杠杆二：输入瘦身——少让 AI 读大文件

一段长上下文里，被缓存覆盖的部分是"相对便宜"的，而新塞进去的每一块内容都是全价输入，还会一直躺在那里被重发。输入瘦身管的正是"每次新喂进去的东西"，这是日常使用中最直接、最频繁能见效的动作。

原则：先定位，再读取，一次只给够用的

# 直接把整个大文件丢给 AI
请读一下 src/App.tsx（共 1800 行）帮我改
# 把整段报错日志原样贴进去（几百 KB）
这是完整日志，帮我找问题

# 先让 AI 自己用搜索定位（token 成本极低）
先 grep 找出 App.tsx 里处理提交的地方，
再只看那一小段并分析
# 只贴日志的关键片段
报错信息如下（截取自报错附近），帮我定位根因：

这里的 grep 是一个在文本里按关键词搜索的命令行工具——你不需要学它，只要知道"让 AI 先搜再读"这句话就够了。

用工具的"外科手术式"能力，别用蛮力

现在的主流助手都内置了精准读取的手段，刻意用它们能省下大量 token：

对付日志和测试输出的"过滤器 Hook"

如果你用 Claude Code，官方给了一个现成的例子：装一个极小的前置 Hook（Hook 就是"在某个动作发生前后自动执行你指定命令"的挂载点），每当 AI 要跑测试，就自动把命令改写成"只输出失败行"。核心思路一句话：别让 AI 看它不需要看的原始输出。官方称这能把上下文从几万 token 压到几百 token。

第一步，把下面这个文件存成 ~/.claude/hooks/filter-test-output.sh：

#!/bin/bash
input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command')
# 只让测试类命令保留失败行
if [[ "$cmd" =~ ^(npm test|pytest|go test) ]]; then
  filtered="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
  echo "$input" | jq --arg f "$filtered" \
    '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"allow",updatedInput:(.tool_input + {command:$f})}}'
else
  echo "{}"
fi

第二步，在设置文件里把它挂到"每次执行命令之前"（PreToolUse 就是这个时机的名字，jq 是处理 JSON（一种通用的数据交换格式）的命令行工具，脚本里用它读改写命令）：

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" }
        ]
      }
    ]
  }
}

第三步，准备目录并给它执行权限：

mkdir -p ~/.claude/hooks
chmod +x ~/.claude/hooks/filter-test-output.sh
# 排查用：Hook 改写命令后，日志里会出现 modified tool input
claude --debug-file ./claude-debug.txt

同类逻辑通用于一切"大块输入"：无论是大文件、长日志、网页正文、接口返回的数据还是项目说明书（README），规则都一条——进上下文之前先瘦身。宁可多花一次廉价的搜索命令，也别多塞一次昂贵的全量内容。

顺便让输出也"小口"一点

输入瘦身管的是"喂进去的"，但输出是 5 倍价，所以顺手也要约束"吐出来的"：明确要求它只给 diff（只显示改了哪几行，而不是重贴整份文件）或摘要、关键行。让 AI"少写废话"和"少读废话"同样重要。

09杠杆三：提示词省钱法——让任务一次到位

省 token 不只靠"压缩输入"，还靠减少往返轮数。AI 每次猜错方向、每次做完又返工，都会触发一整串带全上下文的新请求。把需求讲到位，是最被低估的"免费省钱"。官方成本文档把这条直接点了名：模糊的请求（比如"改进这个代码库"）会触发大范围扫描；具体的请求能让它以最少的文件读取完成工作。

从"模糊差事"到"精确任务"

在 auth.ts 的 login 函数里加输入校验：
用户名 3-20 位、密码至少 8 位且含数字。
输入为空时返回 400。加完跑一下相关单测，只把失败项给我。

四条"一次到位"的纪律

什么时候该"计划先行"，什么时候不用

10杠杆四：吃透缓存——把重复内容打到一折

前面反复提到缓存，现在一次性讲透。它是你唯一能拿到的"数量级折扣"，也是账单里最容易出现十几倍差异的一行。

缓存是什么：逐字节相同的前缀，打一折

大模型接口对逐字节完全相同的前缀提供"缓存命中"优惠：只要这次请求的前缀（按 03 那个顺序：工具定义 → 系统提示 → 项目记忆 → 历史对话）和之前某一次一模一样，这一大段就按输入价的 0.1 倍结算，而不是全价重算。

把话说准：0.1 倍是一折（省 90%），不是"九折"。0.1 倍和九折差了 80 个百分点，旧教程经常写错这一句。同一组倍数在 OpenAI 的定价与缓存文档里也是"读取 0.1 倍 / 写入 1.25 倍"，所以这不是某一家厂商的独家规则。

写入缓存则要加价——这是一次性投入。几个关键数字：

为什么它值得算一遍：两个现成的算式

缓存不是"有折扣就赚"——写入本身要加价，所以要看复用次数。OpenAI 的缓存文档直接把平衡点算给你了：

写一次 + 完整复用一次：1.25（写） + 0.1（读） = 1.35 倍
不用缓存、处理两次：                           = 2.00 倍
复用到十次：1.25（写） + 9 × 0.1（读） = 2.15 倍
不用缓存、处理十次：                   = 10.0 倍

结论很清楚：一个前缀只要会被复用两次以上，缓存就是纯赚；复用越多越赚。这也顺带解释了为什么"稳定但冗长的系统提示与项目记忆"值得进缓存，而"每轮都在变的时间戳"永远不该放进可缓存前缀。

三段层级：改哪儿，失效到哪儿

缓存按层级组织：工具定义 → 系统提示 → 消息（历史）。改动某一层，会连带让这一层之后的所有层级失效：

四件事会"弄丢"缓存，让你按全价重付

• 放太久过期了。缓存有保鲜期（英文缩写 TTL，就是"存多久算数"）：订阅套餐下通常是 1 小时，而一旦你开始动用加购额度，就降回 5 分钟；用 API key 或云厂商时默认就是 5 分钟。你离开键盘去喝了杯咖啡回来继续——如果超过保鲜期，第一条请求就会全价重新预填充整段上下文。
• 前缀内容变了。改了项目记忆文件、系统提示、换了加载的技能文件——前缀一变，后面全部失效。项目记忆"又肥又天天改"是最坏组合。
• 换了模型或思考档位。缓存按模型和思考配置分别保存，会话进行到一半切档，下一批请求全是全价。
• 前缀里掺了"每轮都变"的东西。比如在可缓存前缀里放了当前时间戳、随机 ID 这类每轮都不同的内容——前缀永远对不上，缓存永不命中，等于没开。日期应截到"天"，或者放到最后一个缓存断点之后。

API 用户：断点怎么打

如果你直接调接口，缓存有两种开法：自动缓存（在请求顶层放一个标记，系统自动缓存到最后一个可缓存块）和显式断点（你亲手标在哪里切）。断点要打在稳定内容的末尾，打在每轮都变的那一块上等于每轮都重新写、永远不命中。官方给的自动缓存写法：

{
  "model": "claude-sonnet-5",
  "max_tokens": 1024,
  "cache_control": { "type": "ephemeral" },
  "system": "你是一个长期稳定的项目助手……（前面这段越长越稳定，越值得缓存）",
  "messages": [{ "role": "user", "content": "这次的问题……" }]
}
// 想把保鲜期从默认 5 分钟拉到 1 小时（写入价变 2 倍）：
"cache_control": { "type": "ephemeral", "ttl": "1h" }

还有一个容易被忽略的机制：系统会从断点往回找最多 20 个块的范围内、之前请求已经写过的缓存条目。所以如果会话长到把断点推得离上一次写入太远，就会找不到——这也是官方建议给"增长很长的会话"多留一个断点的原因。

把缓存用成省钱的四招

1. 连续作战，别频繁中断。缓存命中会续期，趁热打铁，同一会话内连续做完，比断断续续强得多。
2. 系统级内容保持稳定且精简。项目记忆、加载的技能文件是每次请求都在缓存前缀里的最重内容——让它短、让它少改（12 给方法）。
3. 会话中途别换模型、别改思考强度。要换就在会话开头定好，一档到底。
4. 别在可缓存前缀里放"每轮都变"的内容。时间戳、随机 ID、当前目录这些都放断点之后。

11按任务分级：选模型档位与思考强度

同一个任务，用贵的档位和用便宜的档位，单价能差几十倍；同一档位里"思考深度"不同，token 花费也能差出几倍。这一节教你做任务分级——把最贵的算力留给真正需要它的那一步。

当前各档单价（Anthropic 首方价，2026-09-13 校对）

官方给的三条铁律很直接：① 大多数编码任务用 Sonnet，成本低于 Opus；② Opus 只留给复杂架构决策或多步推理；③ 简单的子代理任务用 Haiku。别让"最强档位"成为默认档位。

另外记住一条会改掉你估算的事实：官方定价页注明 Sonnet 5 发布时的 $2/$10 促销价现已转为标准价，原定调涨到 $3/$15 的安排不会发生。价格类数字以官方定价页为准，本文只保证校对日期当天的口径。

怎么切：会话内、默认档，以及给子代理单独指定

Claude Code 里 /model 可随时切换，/config 设置默认档位。而"跑腿的"可以单独配便宜档位——给子代理写一份配置文件，指定它用 Haiku：

# .claude/agents/log-scout.md
---
name: log-scout
description: 翻日志、跑测试、抓文档，只把结论带回来
model: haiku
---
你只做一件事：找到我描述的信号，然后返回不超过 200 字的结论 + 涉及文件清单。
不要把原始输出贴回来。

结合 10 要记住：换档位会让该模型的缓存失效。所以"先 Opus 调研、再切 Sonnet 施工"要付出一次全价重建——是否值得，取决于切换前后任务的差异是否足够大。

思考强度是把双刃剑

新一代模型默认会"先思考再动手"，而思考产生的 token 按输出价计费（输出是输入 5 倍）。对复杂任务这钱花得值；但对简单机械活，思考深度可以降下来：

12治理：别让主线之外的"帮手"偷烧 token

除了主线会话，还有几类"隐形的烧钱口子"：外接工具服务器、子代理、团队助手、定时任务。它们单个看着不大，积少成多、又难以察觉。

外接工具服务器（MCP）：能少则少

MCP 是一套让 AI 外接工具的协议——挂上一个服务器，AI 就多出一批可以调用的能力（查数据库、读工单、发消息）。代价是这些工具的说明可能进入你的上下文。

• 能用命令行就别挂服务器。官方明确建议：像 gh、aws、gcloud、sentry-cli 这类有命令行的工具，直接让 AI 跑命令比挂服务器更省上下文，因为它们不产生"每个工具一段说明"的常驻开销。
• 好消息：现在默认是延迟加载。官方说明工具定义默认延迟加载——只有工具名和服务器说明会先进上下文，直到 AI 真的用到某个工具才加载它的详情。（这一点是旧教程的常见错误来源：过去确实会把每个工具的完整说明一起塞进去，现在不是了。）
• 关掉没在用的。用 /mcp 看当前挂了哪些，把用不上的停掉；用 /context 看它们实际占了多少。

子代理：让"大嗓门"在隔音间里干活

子代理（subagent）是一个被派出去独立干活的小 AI：它有自己独立的上下文，干完只把一段摘要交回主会话。跑测试、抓文档、翻日志这类"输出又长又吵"的活，正好交给它——海量输出留在它自己的上下文里，主会话只收到一行结论。

团队助手：人多，烧得也多

如果你的工具支持"多个 AI 同时协作"，官方给的成本事实要记住：

• 每个成员都有自己的独立上下文窗口，总 token 与成员数量大致成正比；
• 官方数据：成员处于计划模式时，团队总消耗可达普通会话的约 7 倍；
• 该功能默认是关闭的——需要在配置或环境变量里设置 CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 才会启用。所以如果你从未开过它，那它不是你账单的原因；如果开过，记得检查有没有忘关的成员。
• 省钱纪律：队伍保持小、成员用 Sonnet 档、交给成员的指令保持聚焦、干完活立刻关掉——一个"忘了关的成员"会持续烧到会话结束。

后台与"挂机"也会走 token

有些消耗发生在你根本没提问的时候，官方成本文档列了几种：到点就响的定时 / 循环任务（每次触发都带着你的完整上下文跑一轮）；跨会话消息（另一个会话发来的消息会在本会话空闲时作为新一轮触发，同样带上全量上下文，可以把入站消息设为挂起而不是直接送达）；目标的空闲检查（后台任务等待期间，工具会主动去问一下进度，官方限制每个目标在你两次提问之间最多 3 次，也可设为 0 关闭）；以及为支持"下次续聊"而做的后台摘要（官方称通常单会话低于 0.04 美元）。

系统级默认负载：把长流程从项目记忆里挪走

每次请求里，系统提示 + 项目记忆都在可缓存前缀里、也最常被自动重发。如果项目把一堆 README、历史备注、工作流全塞进记忆文件，等于给每一次请求都穿上一件沉重的棉袄。官方的建议很直接：项目记忆保持在 200 行以内，只放核心规则；把专项长指令移到按需加载的技能文件里（技能只有被用到时才进上下文）。

# CLAUDE.md（越长越肥，经常追加）
- 项目说明（整段 README 复制）
- 数据库迁移注意事项 v2（已过期）
- 上个月临时加的构建 workaround
- 最近 20 条会议备注
- ……每次改动，缓存前缀就变一次

# CLAUDE.md（200 行内，只放核心）
- 常用命令：dev / test / lint
- 关键约束：不用 XXX 库、目录规范
- 测试入口与常见失败排查
（详细流程指令移进按需加载的技能文件，
 用到才进上下文，不用不占）

三种内容的去处，可以这样分：① 全局铁律（常用命令、硬约束）→ 留在记忆文件；② 某个任务的长流程（代码评审检查、数据库迁移指南）→ 挪进按需加载的技能文件；③ 临时备注 / 过期信息 → 直接删。一句话原则：记忆文件是"每次都在场"的，技能是"按需入场"的——把后者塞进前者，就是无谓的常驻开销。

每周一次的治理检查

13场景实战：三个剧本

把前面所有杠杆拧在一起，看三个最常见的实战场景分别该怎么打。命令以 Claude Code 为例，逻辑通用于其它助手。

剧本 A：一天里的"很多个小改动"

典型画像：早上调了个样式，下午加了个接口，晚上修了个小 bug。三个活毫无关联。

预期收益：相比"一个会话开一天"，每日 token 常能省下一大半，因为再也没有"背着几十万历史问一句小问题"的场面。

剧本 B：接手一个陌生大仓库

典型画像：第一次打开别人的项目，要做一处功能改动，根本不知道代码在哪。

预期收益：把"广撒网探索"的成本压到最低，主会话上下文始终小巧。这一步常常决定"接手大仓库的首次会话"是几美元还是几十美分。

剧本 C：一场持久战式调试

典型画像：一个诡异 bug 查了两小时，会话已经很长，眼看就要触发自动压缩。

预期收益：长调试不断片、不失控；每次"续命"花的都是压缩 / 摘要的钱，而不是背全量历史的钱。

claude -p --max-budget-usd 5.00 "把这批测试失败项归类，只输出结论"

14省 token 一页纸：能贴在桌上的动作清单

把全文浓缩成四组动作。免费的习惯类永远优先于设置类——多数人的问题在习惯，不在配置。

每天开工前

• 把状态栏 / 用量面板打开，让成本可见（这是唯一一次"设置"，收益最大）。
• 给当前会话起个名字（/rename），方便日后 /resume，而不是硬续一个巨会话。

每个任务进行中

• 每轮都问一句：这个会话还该不该继续背这些历史？不相关 → /clear。
• 需求写精确：范围、文件、验收标准一次给够（09）。
• 让它先搜索 / 跳转定位，再只读相关片段（08）。
• 输出要 diff / 摘要，不让它整份重贴文件（输出是 5 倍价）。
• 小步走：改一点、测一点、及时纠偏。
• 会话中途不换模型、不改思考强度（保住缓存，10）。

每个任务收尾

• 看一眼 /usage：命中率低于预期？去找缓存失效的原因；输出占比异常高？反思提示词是不是让它写太多了。
• 干完就 /clear 或结束，别让"半热"的会话挂一整天。

每周一次

• 记忆文件瘦身、外接工具清单清理、定时任务检查、团队助手确认收工、默认档位与预算上限复核——完整表在 12。

如果时间只够做三件事

这三条已经覆盖了大多数人八成的浪费，剩下两成再回到本文对应的节里逐项处理。

15常见坑：那些"悄悄烧钱"的行为

下面这些行为单独看都"只是小事"，叠加起来就是账单上最肥的水分。挨个排查，命中几个就改几个。

八个悄悄烧钱的行为

最容易翻车的三个瞬间

• 深夜挂着会话回消息，隔天第一条缓存过期、全价重算。长会话的上下文可能已有几十万 token，一次失效就是这一整块全价重来。
• 一口气让它读十个文件再"统一改"。方案错了就是"重来一轮 × 十个文件 × 两轮"——这正是剧本 B 要先出方案的原因。
• 把生产日志明文丢给第三方中间件图省事。先想清楚你的代码和密钥在谁手里，再谈省那点 token。

红黑榜速记

16什么时候不该省：四条边界

省钱这件事有明确的失效边界。越界之后的"省"不是省钱，是把成本转移到更贵的地方（返工、事故、返修时间）。这一节把四条线划出来。

边界一：省到 AI 开始猜，就是亏

最典型的越界是把输入砍太狠：不给上下文、不说清验收标准、不让它读必要的文件。结果是它靠猜、猜错再纠错，往返轮数翻倍——返工的成本通常远高于你省下的那点输入。判断法：你省掉的这块信息，是不是它完成任务所必需的？是，就别省。

边界二：别为了省钱全局关掉思考

思考 token 按输出价计费，看起来很像"直接砍掉最划算的一刀"。但官方明确说扩展思考默认开启，是因为它显著提升复杂规划与推理任务的表现。全局关掉的质量损失会以返工的形式回来，而且更贵。正确做法是分级（11）：机械活用低档，硬骨头临时拉高。

边界三：别把缓存优化做成"魔法"

为了把前缀拼得更"可缓存"，把项目记忆拆得七零八落、把工具定义改来改去，读者（包括未来的你）会看不懂这套配置在干什么——维护成本会超过省下的钱。缓存优化的目标是"别去破坏它"，不是"围绕它重构整个项目"。

边界四：有些钱本来就不该省

涉及安全、合规、正确性核验的环节，以及你无法验证输出的高风险任务，本来就应该多花 token 去交叉检查、多派一个代理复核、把关键结论拿官方源核对一遍。这些地方省下来的钱，赔率极差。

一张对照表：该省 vs 不该省

17术语对照表

下面这些词在文中都出现过并且都解释过。这张表是给"读第二遍时回头查"用的，第三列写的是它为什么重要、什么时候用、以及别把它当成什么。

18FAQ：七个最常被问的问题

99一句话总结

98参考来源与证据边界

本文里所有具体数字都来自下面这些一手来源，校对日期为 2026-09-13。价格、模型名、命令行为都属于会变的东西，所以我把"哪一类事实来自哪一页"写清楚，方便你回源核对。

一手来源

• Anthropic — 模型与定价官方页（docs.claude.com/en/docs/about-claude/pricing）：各档输入 / 输出 / 5 分钟缓存写入 / 1 小时缓存写入 / 缓存命中读取的单价；缓存倍率脚注（5 分钟写入 1.25 倍、1 小时写入 2 倍、命中读取 0.1 倍，Fable 5.1 与 Mythos 5.1 为 0.025 倍）；"Claude 4.7 及之后模型的新分词器使同样文本多产出约 30% token"；以及 Sonnet 5 的 $2/$10 已转为标准价、原定的涨价安排取消。本文 11 的单价表逐行取自这里。
• Anthropic — Prompt caching 官方文档（docs.claude.com/en/docs/build-with-claude/prompt-caching）：自动缓存与显式断点两种开法、"一个请求最多 4 个断点"、缓存层级（工具 → 系统 → 消息）与失效规则、最短可缓存长度（按模型 512 / 1024 / 2048 / 4096 token）、默认 5 分钟 TTL 与 1 小时 TTL 的 2 倍写入价、20 个块的向后查找窗口，以及"改思考参数会使消息前缀失效"。
• Anthropic — 上下文窗口官方文档（docs.claude.com/en/docs/build-with-claude/context-windows）：哪些模型是 1M 窗口、单次最多 128k 输出、以及"1M 是默认值且按标准价计费"。
• Anthropic — token 计数官方文档（docs.claude.com/en/docs/build-with-claude/token-counting）：新分词器约 +30%，以及"迁移时不要复用旧模型上量到的计数"。
• Claude Code — Manage costs effectively 官方文档（docs.claude.com/en/docs/claude-code/costs）：本文 04 的 /usage 示例输出、Prompt cache (main) 那一行、"每次请求发送完整对话"、企业均值 $13/活跃日与 $150–250/月、90% 用户低于 $30/日、缓存保鲜期（订阅 1 小时、动用加购额度后 5 分钟、API key 与云厂商默认 5 分钟）、后台开销低于 $0.04/会话、外接工具定义默认延迟加载、项目记忆建议 200 行内、扩展思考按输出价计费、团队助手计划模式下约 7 倍，以及 08 那个 PreToolUse 过滤器脚本的全部内容。
• Claude Code — CLI 参考与交互模式文档：--max-budget-usd 仅打印模式生效、且子代理花费计入上限；/rename、/resume、/effort、/status、/config 等命令的现行行为。
• OpenAI — Pricing 与 Prompt caching 官方文档（platform.openai.com/docs/pricing、/docs/guides/prompt-caching）：跨厂商验证缓存倍率（读取 0.1 倍、写入 1.25 倍）；10 那两个算式（1.35 倍 vs 2 倍、2.15 倍 vs 10 倍）以及"一个请求最多 4 次缓存写入"均取自这里。
• DeepSeek — Models & Pricing、Token & Token Usage、Context Caching 官方文档（api-docs.deepseek.com）：官方给出的 token 与字符换算口径（1 个英文字符 ≈ 0.3 token、1 个汉字 ≈ 0.6 token）；缓存命中与未命中的巨大价差（V4 Pro：命中 $0.022/百万 vs 未命中 $0.66/百万，约三十分之一）；缓存默认开启、按"前缀单元"整段匹配；以及 1M 上下文 / 最大 384K 输出。

本文自己做的核对

• 旧版逐条对账。上一版的每一个可运行示例（账单输出、费用公式、手算过程、"喂太多 / 喂得刚好"两个提示词、"肥 / 精简"两份项目记忆样例）都在新版里有对应物，并且全部按官方现行文档重核了一遍；重核后发现并改掉的过时陈述列在交付报告里。
• 跨厂商对照。"缓存读取 0.1 倍、写入 1.25 倍"这条不是一个厂商的规则——Anthropic 与 OpenAI 两家官方定价页给的是同一组倍数，DeepSeek 的缓存价差甚至更大（约三十分之一）。这说明它是行业通行做法，而不是某家产品的特性。

证据边界与时效

• 价格与倍率是快变量。本文的单价表是 2026-09-13 的口径；官方明确说过会调整价格（本文就记了一次"原定涨价被取消"）。任何涉及预算的决策，请回官方定价页复核当天的数字。这也是本文把 learn:shelf-life 标为 evolving 的原因。
• 命令与界面按 Claude Code 口径。为给出可执行的命令，本文以 Claude Code 为主要示例；其它助手（OpenCode、各类编辑器插件、各家 CLI）的原理相同，但命令名与面板位置可能不同——请查你所用工具的现行文档。
• 没有做的事。我没有在你的机器上实测各类会话的真实账单；没有评测第三方 token 优化工具的效果与安全性（只作风险提示，不作推荐）；也没有覆盖企业级的成本归集、把用量汇总到自家监控系统的做法、以及云厂商（Bedrock / Vertex / Foundry）各自不同的单价细节。
• 一处口径提醒。"$/每百万 token"里的"百万"是 MTok（Million Tokens，百万 token）；本文所有百分比与倍数都是官方页面上的原值，我没有做二次换算。