<!-- title: Claude Code省Token入门与额度管理 -->

## 概述

本教程面向**已经跑通第一个项目、却被"额度怎么这么快就没了"困惑的零基础到入门用户**。你将系统理解 Claude Code 的 Token 计费模型，掌握 `/cost`、`/model`、`/compact`、`/clear`、`.claudeignore`、CLAUDE.md 瘦身与自动缓存（prompt caching）这七招省钱基本功，并通过一个真实会话的"优化前后对比"看到账面成本下降 40%–70% 的效果。学完后你能在不牺牲代码质量的前提下，把每一美元的 API 额度用到刀刃上。

## 前置条件

- 已安装 Claude Code（`claude --version` 可正常输出版本号）。
- 已完成登录：或为 Claude Pro/Max 订阅（按月固定额度），或为按量计费的 Anthropic API Key。
- 一个用来练手的测试仓库（建议是真实但中小型的项目，几百到几千行代码即可，**不要用公司机密仓库**）。
- 基本会使用终端、能看懂 JSON 与目录结构。

> 说明：本教程中的 Token 单价来自 2026 年公开挂牌价，订阅用户按月固定额度、不按单次计费，但"少烧 Token"同样能让你的月度配额用得更久。

---

## 第一步：先搞懂"一次提问"到底烧了什么

新手最常见的误解是："我只问了一句话，怎么会烧这么多 Token？" 原因是 Claude Code 是 **Agent 模式**——你问一句话，它内部可能调用了十几次工具（读文件、搜索、运行命令），每一次工具结果都会作为"上下文"重新发给模型。也就是说，**你付出的不是"一次对话"的钱，而是"整个滚动上下文"反复发送的钱**。

先建立四个计费概念，后面所有招数都围绕它们：

| Token 类型 | 含义 | 单价相对值 | 谁来产生 |
|---|---|---|---|
| **输入 Input** | 本次新发送的提示文本 | 1× | 你的提问 + 新读入的文件/命令输出 |
| **输出 Output** | 模型生成的回复 | 约 5× | 模型写的代码、解释 |
| **缓存写入 Cache Write** | 把稳定前缀存入缓存 | 约 1.25× | Claude Code 自动做 |
| **缓存读取 Cache Read** | 复用已缓存的前缀 | **约 0.1×** | 命中缓存时 |

核心洞察：**同样一段文本，作为"缓存读取"发送的成本只有"普通输入"的十分之一**。这就是为什么"让上下文稳定、命中缓存"是最有效的省钱手段——它不是省了几个 Token，而是把单价砍到一折。

模型档位与单价（2026 年公开挂牌价，每百万 Token，美元）：

| 模型 | 输入 | 输出 | 缓存写入 | 缓存读取 | 适用场景 |
|---|---|---|---|---|---|
| Haiku 4.5 | $1 | $5 | $1.25 | $0.10 | 杂活：格式化、改名、批量正则 |
| Sonnet 4.6 | $3 | $15 | $3.75 | $0.30 | **日常默认**，绝大多数编码任务 |
| Opus 4.7/4.8 | $5 | $25 | $6.25 | $0.50 | 难活：架构设计、棘手 Bug、重构 |

**预期结果**：读完这一步，你应该能在心里给"一次提问"粗略估算成本——比如"这段 3000 行的日志被我让 Agent 读了三次，光输入就累积上万 Token 了"。

**常见问题**：
- *问：我用的是订阅，看不到钱，还要在意吗？* 答：订阅有月度配额（5 小时/周 等窗口限制），配额耗尽就要等重置。省 Token = 配额用得更久 = 少被打断。
- *问：上下文窗口是 200k，是不是用满才划算？* 答：恰恰相反。窗口越大、重复发送越多，钱烧得越快。窗口是"上限"，不是"目标"。

---

## 第二步：用 `/cost` 盯住现场

`/cost` 是入门用户最该养成的习惯——**它是你 Claude Code 里的"实时仪表盘"**，显示当前会话累计消耗的各类 Token 数与折算成本。

操作：在交互式会话中随时输入：

```
/cost
```

典型输出（示意）：

```
Total cost:            $0.42
Total duration (API):  3m 12s
Total duration (wall): 8m 04s
Total code changes:    142 lines added, 18 lines removed

Token usage by model:
  claude-sonnet-4-6:
    Input:             48,210 tokens     $0.14
    Cache read:       186,400 tokens     $0.06    ← 命中缓存，便宜
    Cache write:       22,000 tokens     $0.08
    Output:            5,330 tokens     $0.08
```

**怎么读这张表**：
1. 看 `Cache read` 与 `Input` 的比例。健康会话里 `Cache read` 远大于 `Input`，说明缓存命中好、单价低；若 `Input` 持续很高、`Cache read` 很低，说明你的上下文在反复变动、缓存被打破。
2. 看 `Output` 占比。Output 单价是 Input 的 5 倍，模型啰嗦（输出大段解释）的成本远高于它多读几行代码。
3. 周期性对比。每完成一个小任务跑一次 `/cost`，记住"改一个函数大概花多少"，一旦某次异常飙升，立刻能定位到是哪个操作惹的祸。

**常见问题**：
- *看不到价格只看到 Token 数？* 说明你用的是订阅账号，`/cost` 只统计 Token 不折算金额，原理一样——盯 Token 总量即可。
- *`/cost` 清零吗？* 它统计的是"当前会话"，`/clear` 后会重新开始。

---

## 第三招：`/model` 按任务难度切换档位

默认模型（通常是 Sonnet 4.6）能搞定 90% 的日常编码。真正费钱的是"用大炮打蚊子"——拿 Opus 去跑一个改名重构。

切换模型：

```
/model            # 打开选择菜单
/model sonnet     # 直接切到 Sonnet
/model haiku      # 杂活切到 Haiku
/model opus       # 难活再切回 Opus
```

**性价比分工建议**：

| 任务 | 推荐模型 | 理由 |
|---|---|---|
| 批量改函数名、格式化、生成测试桩、写注释 | Haiku | 单价最低，质量足够 |
| 写业务逻辑、修普通 Bug、读代码理解 | Sonnet | 综合最优，默认档 |
| 跨文件架构重构、诡异并发 Bug、设计评审 | Opus | 能力最强，用在对的地方 |

**预期结果**：把 30% 的"机械活"从 Sonnet 挪到 Haiku，整体成本能下降 20%–40%，而你看不出质量差别。

**常见问题**：
- *切模型会怎样？* 见下一招——切模型会打破缓存，别频繁来回切。
- *Fast 模式是什么？* Fast 模式仍是 Opus、只是出字更快，**不省钱**，按需用。
- *怎么知道该不该升 Opus？* 当 Sonnet 在同一个 Bug 上来回改了 3 次还不对，就该 `/model opus` 上场了——这比让 Sonnet 死磕更省。

---

## 第四招：让自动缓存（prompt caching）为你打工

这是**最重要的一招**，因为缓存读取单价只有普通输入的十分之一。Claude Code 的缓存是**自动管理**的，但你的操作习惯决定它能不能命中。

**缓存原理（前缀匹配）**：模型把上下文按顺序看作一个长文本，**只要前面那一长段没变，就能命中缓存**。一旦中间任何一处发生变化，从该处往后全部失效、需要重新写入。

会**打破缓存**的操作（这些会让单价从 0.1× 飙回 1×）：

1. **中途切模型**（`/model`）——不同模型的缓存不通用，切一次清空一次。
2. **频繁改 CLAUDE.md / 系统提示**——它们排在上下文最前面，一动全失效。
3. **改动后立刻重发整段**——例如你手改了文件又把内容贴进对话，等于重新注入。
4. **`/compact` 之后的第一轮**——压缩会重写历史，缓存需要重建（但之后会更紧凑、更省）。

**能保住缓存的好习惯**：

- **一个任务一个会话**，别在同一个会话里横跳多个不相关项目。
- **让 Agent 自己读文件**（用相对路径引用 `src/auth/login.ts`），而不是你手动复制粘贴代码块——前者走工具调用、可缓存，后者每次都是新输入。
- **稳定你的目录结构**：进入项目后不要在会话中途 `cd` 到完全不同的仓库。
- **连续追问**：在同一个上下文里连续深挖一个问题，比隔三差五重新解释背景要便宜得多。

**预期结果**：养成"连续追问、少粘贴、少切模型"的习惯后，`/cost` 里的 `Cache read` 会明显增大、`Input` 缩小，单位产出的成本肉眼可见地下降。

**常见问题**：
- *缓存有保质期吗？* 有，通常约 5 分钟空闲后缓存过期。如果你去喝了杯咖啡回来继续，第一轮会重新写入缓存（贵一次），之后又恢复便宜。这是正常的。
- *我能手动控制缓存吗？* 入门阶段不用。Claude Code 会自动把稳定的系统提示和早期历史加入缓存。你只需"别去破坏它"。

---

## 第五招：`/compact` 还是 `/clear`？

当会话变长，你有两条路：

- **`/compact`**：把当前历史**压缩成摘要**，保留关键结论（改了哪些文件、做了什么决定），丢掉冗余细节。适合"同一个任务还要继续做"。
- **`/clear`**：**彻底清空**历史，从空白重新开始。适合"任务已完成、要换一个全新任务"。

决策依据很简单：**还要不要这个上下文？**

| 你的状态 | 该用 |
|---|---|
| 任务没做完，但对话已经很长、开始变慢变贵 | `/compact` |
| 当前任务彻底结束，要开始无关的新任务 | `/clear` |
| 不确定 | 优先 `/compact`，错了还能继续；`/clear` 是不可逆的 |

进阶用法——带指令压缩，把重点钉死：

```
/compact 重点保留：auth 模块的改动清单和待办 TODO
```

**预期结果**：一个会话跑了 1 小时后，`/compact` 能把上下文从十几万 Token 压回两三万，后续每一轮都明显变快变省。

**常见问题**：
- *`/compact` 会丢信息吗？* 会丢细节（比如某次中间尝试的报错全文），但会保留结论。如果你担心，先让 Agent 把关键信息写进文件或 CLAUDE.md，再 compact。
- *多久 compact 一次？* 没有固定数字。当你感觉回复变慢、或 `/cost` 增长明显加速时，就是信号。

---

## 第六招：用 `.claudeignore` 把噪音挡在门外

Agent 在探索项目时会用搜索工具（Glob/Grep）扫描文件，**每读一个无关文件，就把它的内容塞进上下文**——这些 Token 纯属浪费。`.claudeignore` 的作用和 `.gitignore` 一样：列在这里的文件/目录不会被 Agent 自动读取。

在项目根目录新建 `.claudeignore`，典型内容：

```
# 依赖与构建产物
node_modules/
dist/
build/
.next/
target/

# 锁文件与大日志
package-lock.json
yarn.lock
*.log
pnpm-lock.yaml

# 媒体与二进制
*.png
*.jpg
*.mp4
*.zip

# 生成的报告、覆盖率
coverage/
*.min.js
```

**为什么这能省钱**：一个中型前端项目，`node_modules` + 锁文件 + `dist` 动辄上百万 Token。一旦 Agent 误读进去，不仅烧钱，还会干扰它的判断。挡掉它们 = 上下文更干净 = 命中缓存更稳 = 三重省钱。

**预期结果**：加了合理的 `.claudeignore` 后，会话初期的 `Input` Token 会明显下降，且不容易出现"Agent 被无关代码带偏"的情况。

**常见问题**：
- *挡得太狠，Agent 找不到文件怎么办？* `.claudeignore` 只影响"自动探索"，你**显式**指定路径（`看一下 src/config.ts`）仍然能读。先挡大块头，遇到找不到的再针对性放行。
- *和 `.gitignore` 一样吗？* 语法兼容，但是两套独立配置。建议 `.claudeignore` 比 `.gitignore` 更激进一点（连日志、覆盖率一起挡）。

---

## 第七招：CLAUDE.md 瘦身与会话聚焦

CLAUDE.md 是项目的"长期记忆"，排在上下文最前面，**每次提问都会被发送**。它越长，你每一轮都白付越多的固定成本。

**瘦身三原则**：
1. **只放真正稳定、每次都需要的信息**：项目结构约定、构建/测试命令、代码风格红线。
2. **删掉一次性内容**：某次重构的临时备注、过期的 TODO，这些不该留在常驻记忆里。
3. **用引用代替粘贴**：与其把一份 200 行的规范全文贴进 CLAUDE.md，不如写一行"详见 `docs/coding-standards.md`"，让 Agent 在需要时才去读。

**会话聚焦**：一个会话只解决一类问题。在同一个会话里既改 Bug、又写文档、又做重构，会让上下文越来越大且杂，缓存也难命中。**任务边界清晰 = 上下文精简 = 省钱**。

**预期结果**：把臃肿的 CLAUDE.md 从 300 行精简到 60 行，每一轮提问的固定开销直接下降，且模型反而更聚焦（信息越精炼，注意力越集中）。

**常见问题**：
- *那自动记忆（memory）文件算吗？* 算。它们同样占上下文。定期清理过时记忆，跟瘦身 CLAUDE.md 是一个道理。
- *项目级和用户级 CLAUDE.md 怎么分？* 通用偏好（语言、风格）放用户级；项目特有约定（命令、架构）放项目级，避免重复。

---

## 实战案例：把一次 Bug 修复的成本砍掉 60%

场景：一个 Node.js 项目里 `src/auth/login.ts` 的登录逻辑有 Bug，Sonnet 4.6，从零开始排查。

**❌ 新手做法（烧钱版）**：

1. 打开会话，直接把 `login.ts` 的 800 行代码**整体粘贴**进对话："帮我看看这有什么问题"。
2. Sonnet 读完，给了个猜测。
3. 新手手改了代码，又把改后的 800 行**再次粘贴**："这样对吗？"
4. 中途想试试 Opus，`/model opus`。
5. 又跑偏，把项目里 5 个无关文件也粘进来"你顺便看看"。
6. 最后 `/cost` 一看：单 Input 累计超过 6 万 Token，Cache read 几乎为 0，花了约 $0.9。

**✅ 优化做法（省钱版）**：

1. 先在根目录加好 `.claudeignore`（挡掉 `node_modules`、锁文件、`dist`、日志）。
2. 把 CLAUDE.md 精简到"构建用 `pnpm build`、测试用 `pnpm test`、登录模块在 `src/auth/`"。
3. 进入会话，**只给路径不给内容**："看一下 `src/auth/login.ts`，登录成功后 token 没写进 response，帮我定位。"
4. 让 Sonnet **自己用工具读文件**，连续追问，中途**不切模型、不粘贴整段代码**。
5. 让它改完后直接说明改了哪几行；你只在它输出后跑 `pnpm test` 验证，把**测试结果**（而非源码全文）反馈给它。
6. 持续 5 轮后 `/cost`：Input 约 1.2 万，Cache read 约 4 万，花了约 $0.12。

**对比**：同样解决问题，成本从约 $0.9 降到约 $0.12，下降约 85%；即便保守估计，综合多轮场景通常也能稳定砍掉 40%–60%。

**为什么有效**（逐条对应招数）：
- 路径引用代替粘贴 → 减少 Input（第三/四招）
- 不切模型、连续追问 → 保住缓存（第四招）
- `.claudeignore` → 挡掉噪音（第六招）
- 只反馈测试结果而非全文 → 控制增量（第四招）
- CLAUDE.md 精简 → 降低固定开销（第七招）

---

## 工作流程图

```text
flowchart TD
    A[开始一个任务] --> B{是否新任务/换项目?}
    B -- 是 --> C[/clear 清空历史]
    B -- 否 --> D{上下文是否已很长/变慢?}
    D -- 是 --> E[/compact 压缩历史]
    D -- 否 --> F[继续当前会话]
    C --> F
    E --> F
    F --> G[选对模型档位<br/>杂活Haiku / 日常Sonnet / 难活Opus]
    G --> H[用路径引用代替粘贴<br/>让Agent自己读文件]
    H --> I[连续追问 不频繁切模型<br/>保住缓存命中]
    I --> J[阶段性运行 /cost 检查]
    J --> K{Cache read 是否远大于 Input?}
    K -- 是 --> L[健康 继续推进]
    K -- 否 --> M[排查: 是否切了模型?<br/>是否粘了大段? 是否读了无关文件?]
    M --> H
    L --> N[任务完成]
    N --> O[/clear 或开新会话<br/>开始下一个任务]

    style A fill:#e1f5ff
    style N fill:#e8f5e9
    style M fill:#fff3e0
```

这张图把"七招"串成一个可循环的日常动作流：**清场 → 选档 → 轻量提问 → 保缓存 → 看仪表盘 → 异常回溯**。每次额度飙升，从 `M` 节点回溯，几乎都能找到原因。

---

## 延伸阅读

- **官方命令参考**：`code.claude.com/docs/en/commands`——`/cost`、`/compact`、`/clear`、`/model` 的权威说明。
- **官方缓存机制文档**：`code.claude.com/docs/en/prompt-caching`——为什么"切模型触发一次未缓存的慢请求"，缓存的前缀匹配原理。
- **上下文管理专题**：SitePoint、SFEIR Institute 都有长会话上下文管理的进阶实战。
- **成本优化实战博客**：baeseokjae 的 "How to Cut Claude Code Costs by 70%"、Marcin Sałata 的 prompt-caching 实测。
- **模型定价页**：`platform.claude.com/docs/en/about-claude/pricing`——最新挂牌价与缓存读写费率。

---

## 训练营适用性评估

- **适合类型**：所有"Claude Code 入门到进阶"类训练营的**第一天的下午必修课**。无论学员后续走 Skill、MCP 还是 Agent 自动化方向，Token 与额度管理都是地基。
- **前置衔接**：放在"安装与首次运行"之后、"写第一个真实功能"之前效果最好——学员刚产生"烧钱"焦虑时，正是接受这套方法的时机。
- **预计教学时长**：讲授 + 演示约 45 分钟；动手实验（用 `/cost` 对比自己优化前后）约 30 分钟；合计约 75 分钟。
- **考核建议**：让学员提交一个会话的 `/cost` 截图，要求 `Cache read / Input > 3`（即缓存命中率健康），即可视为掌握。
- **进阶出口**：本教程是"手动省钱"，后续可接"用 hooks 自动限制 Token 预算""用 `/loop` 与子 Agent 做规模化任务时的成本治理"等高阶主题。

---

## 参考来源

1. [Claude Code Commands 官方文档](https://code.claude.com/docs/en/commands) — `/cost`、`/compact`、`/clear`、`/model` 等斜杠命令的权威参考。
2. [How Claude Code uses prompt caching 官方文档](https://code.claude.com/docs/en/prompt-caching) — 缓存的自动管理、前缀匹配、模型切换导致缓存失效的原理。
3. [How to Cut Claude Code Costs by 70%（baeseokjae）](https://baeseokjae.github.io/posts/claude-code-cost-optimization-guide-2026/) — 缓存、Token 上限与预算强制的实战，40%–70% 成本下降的依据。
4. [Claude Code Cheat Sheet 2026（computingforgeeks）](https://computingforgeeks.com/claude-code-cheat-sheet/) — Opus 4.8 默认、斜杠命令与 CLI flags 的速查表。
5. [Claude API Pricing 2026（cloudzero / aicostcheck）](https://www.cloudzero.com/blog/claude-api-pricing/) — Haiku 4.5、Sonnet 4.6、Opus 4.7/4.8 的每百万 Token 挂牌价与缓存读写费率。

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)