【claude省token系列】程序员必看：Claude Code 省 Token 终极指南——从烧钱到精打细算

发布日期：2026年2月12日 标签：Claude Code | Token优化 | 开发效率 | 成本控制 阅读时长：15分钟

前言：程序员的 Token 焦虑

如果你是一个每天用 Claude 写代码的程序员，你一定经历过这样的场景：

• 早上10点开始用 Claude Code 写功能，下午3点一看，今天的 Token 额度已经烧完了
• 一个简单的 Bug 修复，Claude 把整个项目扫了一遍，Token 哗哗地流
• 让 Claude 改个按钮颜色，它读了20个文件、写了一大堆分析，最后改了一行 CSS
• 月底一看账单，Claude API 的费用比预期多出了3倍

Token 消耗太快，已经成为程序员使用 Claude 的第一痛点。

但问题往往不是 Claude 太贵，而是我们的使用方式太粗放。就像一辆跑车，你不能一直踩油门不松脚——得学会什么时候踩、什么时候松、什么时候切换挡位。

本文将从 Claude Code（CLI/IDE插件） 的角度出发，分享我在实际开发中总结的省 Token 方法论。不讲空话，全是可以立刻用起来的实操技巧。

💡 本系列全程使用 weelinking 访问 Claude， 国内可稳定使用

目录

• 一、搞懂 Token 到底花在哪了
• 二、Claude Code 内置的省 Token 利器
• 三、项目配置层面的优化
• 四、使用习惯：最被低估的省 Token 手段
• 五、进阶策略：让每一个 Token 都值钱
• 六、真实案例：同一个任务，消耗差3倍
• 七、总结：省 Token 的核心心法

一、搞懂 Token 到底花在哪了

在优化之前，你必须先搞明白：Token 到底是怎么消耗的？

1.1 Token 消耗的三大来源

┌──────────────────────────────────────────────────┐
│ 一次 Claude Code 交互 │
│ │
│ 输入 Token（你要为此付费） │
│ ┌─────────────────────────────────────────────┐ │
│ │ ① 系统提示词（Claude Code 内部指令） ~2000 │ │
│ │ ② 对话历史（之前所有的来回） ~变动 │ │
│ │ ③ 工具调用结果（读文件、搜索结果） ~变动 │ │
│ │ ④ 你当前的提示词 ~100 │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ 输出 Token（你也要为此付费，且更贵） │
│ ┌─────────────────────────────────────────────┐ │
│ │ ⑤ Claude 的回复文本 │ │
│ │ ⑥ Claude 调用工具的指令 │ │
│ └─────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────┘

关键认知：每一轮对话，Claude 都要重新加载之前所有的对话历史。

这意味着：

• 第1轮：输入 = 系统提示(2000) + 你的问题(100) = 2100 tokens
• 第5轮：输入 = 系统提示(2000) + 历史(8000) + 你的问题(100) = 10100 tokens
• 第10轮：输入 = 系统提示(2000) + 历史(25000) + 你的问题(100) = 27100 tokens

对话越长，每一轮的成本就越高——这是指数级增长的。

1.2 Claude Code 中 Token 消耗的隐形大户

很多程序员不知道，以下操作会消耗大量 Token：

最容易被忽视的是工具调用的返回结果——文件内容、搜索结果都会被塞进上下文。

1.3 各模型的成本差异

Opus 的输出价格是 Haiku 的近19倍。 如果你所有任务都用 Opus，那确实会烧钱。

二、Claude Code 内置的省 Token 利器

Claude Code 其实自带了很多省 Token 的功能，但大部分程序员都没用起来。

2.1 /compact 命令——对话瘦身神器

这是 省 Token 的第一大杀器。

当对话越来越长，/compact 会将之前的对话历史压缩成一段摘要，大幅减少上下文占用。

使用方法：

# 在 Claude Code 中直接输入
/compact

# 还可以带自定义指令，告诉 Claude 压缩时保留什么
/compact 保留所有代码修改记录和文件路径，丢弃分析过程

效果对比：

压缩前：
对话历史 = 25000 tokens（10轮对话的完整记录）

/compact 后：
对话历史 = 3000 tokens（一段精炼摘要）

节省：88%

最佳使用时机：

• 对话超过 5 轮时
• 完成一个子任务准备开始下一个时
• 感觉 Claude 响应变慢时（上下文太长会变慢）
• Token 消耗速度明显加快时

实战技巧： 你可以在 Claude Code 的设置中配置自动压缩的阈值，当对话历史超过一定 Token 数时自动触发 compact。

2.2 /model 命令——动态切换挡位

不同任务用不同模型，这是最简单有效的省钱方式。

# 切换到 Haiku（便宜快速）
/model haiku

# 切换到 Sonnet（均衡之选）
/model sonnet

# 切换到 Opus（重型任务）
/model opus

什么时候用什么模型：

Haiku（省钱模式）：
✅ 生成简单的 CRUD 代码
✅ 格式化/美化代码
✅ 添加注释和文档
✅ 简单的文件重命名/移动
✅ 数据格式转换（JSON ↔ YAML）
✅ 写单元测试（模式化的）

Sonnet（日常模式）：
✅ 功能开发
✅ Bug 调试
✅ 代码审查
✅ 重构
✅ 写复杂测试

Opus（性能模式）：
✅ 系统架构设计
✅ 复杂算法实现
✅ 跨模块的大规模重构
✅ 安全审计
✅ 性能优化分析

一个实际的开发流程可能是这样的：

09:00 – 用 Haiku 生成数据模型样板代码 → 省钱
09:30 – 切 Sonnet 实现业务逻辑 → 均衡
11:00 – 切 Opus 设计微服务间的通信架构 → 该花的花
11:30 – 切回 Haiku 根据设计生成 Protobuf 文件 → 省钱
14:00 – 用 Sonnet 写集成测试 → 均衡

2.3 /clear 命令——彻底清场

/clear

当你完全切换任务时，/clear 会清空整个对话历史。比 /compact 更彻底——直接归零。

什么时候用 /clear：

• 从项目 A 的任务切换到项目 B
• 之前的对话完全不需要参考了
• 想获得一个"干净"的开始

什么时候用 /compact 而不是 /clear：

• 还在同一个任务中，但对话太长了
• 需要 Claude 记住之前做了什么修改

2.4 Plan Mode（Shift+Tab）——先想后做

这是一个严重被低估的省 Token 功能。

没有 Plan Mode 的开发过程：

你：帮我实现用户认证功能
Claude：好的，让我来实现…
[读取 10 个文件] → 消耗 20000 tokens
[写了一版代码] → 消耗 3000 tokens
你：不对，我想用 JWT 不是 Session
Claude：好的，让我重新来…
[又读取 8 个文件] → 消耗 16000 tokens
[重写代码] → 消耗 3000 tokens
你：认证中间件放错位置了
Claude：抱歉，让我调整…
[再读取 5 个文件] → 消耗 10000 tokens
[再次修改] → 消耗 2000 tokens

总消耗：约 54000 tokens（反复读文件 + 反复重写）

使用 Plan Mode 的开发过程：

你：[按 Shift+Tab 进入 Plan Mode]
你：帮我实现用户认证功能
Claude：[Plan 模式——只读取必要文件、只输出方案，不写代码]
方案：
1. 使用 JWT + Refresh Token
2. 中间件放在 middleware/auth.go
3. 涉及文件：auth.go, router.go, user_handler.go
你觉得这个方案如何？

你：方案OK，开始实现吧
Claude：[退出 Plan Mode，按照确认的方案一次性实现]
[精确读取 3 个文件] → 消耗 6000 tokens
[一次性写完代码] → 消耗 3000 tokens

总消耗：约 12000 tokens
节省：78%

核心原理：Plan Mode 让 Claude 先规划再执行，避免了"试错→推倒→重来"的循环。

2.5 子代理（Subagent）机制——Claude Code 的省 Token 暗招

Claude Code 内部有一个子代理架构，它会把一些探索性任务交给更小更便宜的模型去执行。

比如当你说"找一下项目中所有处理用户认证的文件"，Claude Code 不会用主模型去一个个搜索，而是启动一个子代理来快速完成探索工作。

你能做的优化：

❌ "找到所有认证相关代码并重构它们"
（Claude 会用主模型完成所有工作）

✅ 分两步：
第一步："帮我找到所有认证相关的代码文件"
（Claude 可能用子代理完成，更便宜）
第二步："根据上面的结果，重构认证模块"
（主模型精确执行）

✅ "这个项目的目录结构是怎样的？"
✅ "搜索所有包含 handleAuth 的文件"
✅ "这个函数在哪些地方被调用了？"

这类问题 Claude Code 倾向于交给子代理处理，成本更低。

三、项目配置层面的优化

3.1 .claudeignore——让 Claude 别看不该看的

这是投入产出比最高的配置。.claudeignore 的语法和 .gitignore 一样，告诉 Claude 哪些文件不需要扫描。

在项目根目录创建 .claudeignore：

# 依赖目录——这是 Token 黑洞
node_modules/
vendor/
.venv/
__pycache__/

# 构建产物
dist/
build/
out/
*.min.js
*.min.css
*.bundle.js

# 锁文件——又大又没用（对 Claude 来说）
package-lock.json
yarn.lock
pnpm-lock.yaml
go.sum
Cargo.lock
poetry.lock
composer.lock

# 资源文件
*.png
*.jpg
*.gif
*.svg
*.ico
*.woff
*.woff2
*.ttf
*.eot

# 日志和临时文件
*.log
*.tmp
.DS_Store
Thumbs.db

# 测试覆盖率报告
coverage/
.nyc_output/
htmlcov/

# IDE 配置（通常不需要 Claude 看）
.idea/
.vscode/settings.json
*.swp
*.swo

# 大型数据文件
*.sql
*.csv
*.xlsx
data/
fixtures/

效果有多明显？

一个典型的 Node.js 项目：
├── src/ (200 个文件，50000 tokens)
├── node_modules/ (30000 个文件，不知道多少 tokens)
├── dist/ (50 个文件，80000 tokens)
├── package-lock.json (单个文件 50000 tokens)
└── coverage/ (100 个文件，20000 tokens)

没有 .claudeignore：
Claude 可能扫描到 node_modules 或 lock 文件 → 灾难

有 .claudeignore：
Claude 只看 src/ 和配置文件 → 精准高效

3.2 CLAUDE.md——一次配置，永久省 Token

在项目根目录创建 CLAUDE.md，把你每次都要重复告诉 Claude 的信息写在里面。

# CLAUDE.md

## 项目概述
这是一个 Go 微服务项目，使用 Gin 框架，PostgreSQL 数据库。

## 技术栈
– Go 1.22
– Gin Web 框架
– GORM（ORM）
– PostgreSQL 15
– Redis（缓存）
– Docker + K8s 部署

## 项目结构
– cmd/ → 入口文件
– internal/ → 业务代码
– pkg/ → 公共库
– api/ → API 定义（Protobuf）
– deploy/ → 部署配置

## 编码规范
– 错误处理使用 pkg/errors 包装
– 日志使用 zap
– 所有 API 返回统一的 Response 结构体
– 数据库操作统一在 repository 层

## 常用命令
– 构建：make build
– 测试：make test
– 本地运行：make run

为什么这样做能省 Token？

没有 CLAUDE.md 时：
你："这是一个 Go 项目，用的 Gin 框架…" → 每次都要说，50 tokens × N 次
你："测试命令是 make test…" → 每次都要说，20 tokens × N 次
你："代码风格要求是…" → 每次都要说，100 tokens × N 次

有 CLAUDE.md 时：
CLAUDE.md 在对话开始时加载一次 → 只消耗一次
你的每次提问只需要说核心需求 → 每次只要 10-30 tokens

进阶用法——在子目录放置局部 CLAUDE.md：

project/
├── CLAUDE.md ← 全局配置
├── frontend/
│ └── CLAUDE.md ← 前端特定配置（React 规范等）
├── backend/
│ └── CLAUDE.md ← 后端特定配置（API 规范等）
└── infra/
└── CLAUDE.md ← 基础设施配置（K8s 规范等）

Claude Code 会根据你当前操作的文件路径，自动加载对应目录的 CLAUDE.md，不会一次性加载所有子目录的配置。

3.3 合理设置 allowedTools

在 .claude/settings.json 中，你可以配置允许 Claude 自动使用的工具：

{
"permissions": {
"allow": [
"Read",
"Glob",
"Grep"
],
"deny": []
}
}

为什么这能省 Token？

每次 Claude 需要使用一个受限的工具，它会先生成一段"请求权限"的文本，你确认后它再执行——这个来回本身就消耗 Token。

把常用的只读工具（Read、Glob、Grep）设为自动允许，减少不必要的权限确认来回。

四、使用习惯：最被低估的省 Token 手段

工具和配置只能帮你省一部分，使用习惯才是决定 Token 消耗的核心变量。

4.1 精准描述需求——一次到位

❌ 模糊需求（导致 Claude 大海捞针式地读文件）：
"优化一下登录功能"

Claude 的反应：
→ 读取整个 auth 目录（5个文件，10000 tokens）
→ 读取路由配置（2000 tokens）
→ 读取中间件（3000 tokens）
→ 输出一大段分析报告（2000 tokens）
总消耗：17000+ tokens

✅ 精准需求（Claude 直奔目标）：
"修改 internal/auth/login.go 中的 HandleLogin 函数，
将密码校验从 MD5 改为 bcrypt，参考 golang.org/x/crypto/bcrypt"

Claude 的反应：
→ 只读取 login.go（2000 tokens）
→ 精确修改代码（500 tokens）
总消耗：2500 tokens

节省：85%

精准描述的公式：

[做什么] + [在哪个文件] + [具体修改什么] + [参考什么]

例子：
"在 src/utils/format.ts 的 formatDate 函数中，
将日期格式从 YYYY-MM-DD 改为 MM/DD/YYYY，
使用 dayjs 库"

4.2 告诉 Claude 不要做什么

这招非常管用——主动限制 Claude 的行为范围。

✅ "修改 login.go 中的密码校验逻辑。
不需要修改其他文件。
不需要添加测试。
不需要解释原理。
直接给出修改后的代码。"

特别好用的限制语：

4.3 分阶段开发，不要一口吃成胖子

❌ 一次性要求太多：
"帮我实现一个完整的用户系统，包括注册、登录、
修改密码、忘记密码、邮箱验证、OAuth第三方登录、
权限管理、角色分配…"

Claude 会尝试一次性处理所有内容，
读取大量文件，生成巨量代码，
上下文迅速膨胀 → Token 疯狂消耗

✅ 分阶段处理：
第1次对话："/clear 后 → 实现用户注册和登录"
第2次对话："/clear 后 → 实现修改密码和忘记密码"
第3次对话："/clear 后 → 实现 OAuth 第三方登录"
第4次对话："/clear 后 → 实现权限管理"

每次对话都是干净的上下文，
没有历史累积 → Token 消耗可控

黄金法则：每个对话只做一件事，做完 /clear 或 /compact。

4.4 先审查再改——避免返工

返工是最大的 Token 浪费。一次 “不对，重来” 至少浪费一轮完整的输入+输出。

✅ 审查优先的工作流：

第一步：让 Claude 先说方案
"我想把用户模块从单体拆成微服务，
你先告诉我你打算怎么拆，涉及哪些文件，
不要动手改代码。"

第二步：确认方案后再执行
"方案可以，按你说的执行。"

4.5 善用复制粘贴，少让 Claude 自己找

❌ 让 Claude 自己找：
"找到那个处理订单的函数然后修改它"
→ Claude 需要搜索 + 读取多个文件 → 消耗大量 Token

✅ 直接告诉它在哪：
"修改 internal/order/service.go:45 的 CreateOrder 函数"
→ Claude 直接定位 → 省 Token

✅ 甚至可以直接贴代码：
"修改以下函数，将返回值从 error 改为 (Order, error)：
```go
func CreateOrder(ctx context.Context, req CreateOrderReq) error {
// …
}
```"
→ Claude 不需要读任何文件 → 最省 Token

五、进阶策略：让每一个 Token 都值钱

5.1 Headless 模式 + max_turns 控制

如果你通过 CLI 使用 Claude Code，可以用 headless 模式配合 –max-turns 限制交互轮数：

# 限制最多 3 轮交互，防止 Claude 无限制地探索
claude –max-turns 3 -p "修复 login.go 中的空指针异常"

# 单轮执行，最省 Token
claude –max-turns 1 -p "在 user.go 的 User 结构体中添加 Phone 字段"

适用场景：

• 明确知道任务很简单，不需要多轮交互
• 批量处理脚本，需要控制总成本
• 防止 Claude “过度思考”

5.2 Extended Thinking 的成本意识

Claude 的 Extended Thinking（扩展思考）会产生额外的 Token 消耗。思考过程中的 Token 虽然价格较低，但数量可能很大。

建议：

• 简单任务不需要扩展思考
• 复杂的架构设计、算法优化才值得开启
• 在 Claude Code 中可以通过 /model 切换到 Haiku 来避免不必要的深度思考

5.3 Prompt Caching——API 用户的大杀器

如果你通过 API 调用 Claude，一定要用 Prompt Caching。

import anthropic

client = anthropic.Anthropic()

# 把项目文档、编码规范等固定内容标记为可缓存
response = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=1024,
system=[
{
"type": "text",
"text": "你是一个 Go 语言专家…",
},
{
"type": "text",
"text": open("CODING_STANDARDS.md").read(), # 5000 tokens 的编码规范
"cache_control": {"type": "ephemeral"}
}
],
messages=[
{"role": "user", "content": "审查这段代码…"}
]
)

缓存命中时，输入价格降至原价的 1/10。 如果你有固定的大段上下文（项目文档、代码规范、API 定义等），Prompt Caching 能节省 60-90% 的输入成本。

5.4 API 调用时限制输出长度

# 只需要简短回答时，限制 max_tokens
response = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=200, # 限制输出长度
messages=[
{"role": "user", "content": "这段代码有 bug 吗？只说有没有，以及在哪一行。"}
]
)

别小看这个参数——如果不限制，Claude 可能输出 2000 tokens 的详细分析，但你只需要一句话的结论。

5.5 Token 用量监控

Claude Code 中查看用量：

在 Claude Code 的对话中，你可以注意右下角或状态栏显示的 Token 消耗信息。

API 调用后获取精确用量：

response = client.messages.create(...)

# 查看本次调用的 Token 消耗
print(f"输入: {response.usage.input_tokens} tokens")
print(f"输出: {response.usage.output_tokens} tokens")

# 计算成本（以 Sonnet 为例）
input_cost = response.usage.input_tokens * 3 / 1_000_000
output_cost = response.usage.output_tokens * 15 / 1_000_000
print(f"本次成本: ${input_cost + output_cost:.4f}")

建议：每周看一次用量统计，找出哪些操作最烧钱，针对性优化。

六、真实案例：同一个任务，消耗差3倍

任务：为一个 Go Web 项目添加 JWT 认证中间件

程序员 A 的做法（粗放型）：

第1轮："帮我加个 JWT 认证"
→ Claude 扫描整个项目结构（读取 15 个文件）
→ Claude 输出详细的方案分析
→ 输入: 30000 tokens, 输出: 2000 tokens

第2轮："不对，我用的是 Gin 框架不是 Echo"
→ Claude 重新读取文件，重新生成代码
→ 输入: 35000 tokens, 输出: 3000 tokens

第3轮："中间件放错位置了，应该在 middleware/ 目录"
→ Claude 再次调整
→ 输入: 40000 tokens, 输出: 1500 tokens

第4轮："Token 刷新逻辑也加上"
→ 上下文已经很大了
→ 输入: 45000 tokens, 输出: 2000 tokens

总计：输入 150000 tokens + 输出 8500 tokens
成本（Sonnet）: $0.45 + $0.13 = $0.58

程序员 B 的做法（精细型）：

准备工作：
✅ 项目已有 CLAUDE.md（写明了 Gin 框架、项目结构）
✅ 已配置 .claudeignore（排除 vendor/ 等）

第1轮：[使用 Plan Mode]
"在 middleware/ 目录新增 JWT 认证中间件，
需要 Token 刷新逻辑，
参考 github.com/golang-jwt/jwt/v5，
先说方案不要写代码。"

→ Claude 只读取 2-3 个关键文件
→ 输出简短方案
→ 输入: 5000 tokens, 输出: 800 tokens

第2轮："方案OK，实现它。"
→ Claude 精确实现
→ 输入: 8000 tokens, 输出: 2000 tokens

/compact

第3轮（如果需要微调）："修改 middleware/jwt.go:35，
将 Token 过期时间从 1 小时改为 2 小时"
→ 输入: 4000 tokens, 输出: 300 tokens

总计：输入 17000 tokens + 输出 3100 tokens
成本（Sonnet）: $0.051 + $0.047 = $0.098

对比结果：

同样的结果，成本差了近6倍。日积月累，差距是巨大的。

七、总结：省 Token 的核心心法

速查表：15 个省 Token 技巧

三句核心心法

1. 减少输入： 别让 Claude 读不该读的东西——配好 .claudeignore，写好 CLAUDE.md，精准定位文件。

2. 减少轮次： 一次把事情说清楚——用 Plan Mode 先对齐方案，避免返工带来的 Token 加倍消耗。

3. 控制上下文： 对话是会膨胀的——及时 /compact 或 /clear，别让历史拖垮你的 Token 预算。

终极建议

如果你只记一条，记这条：

每完成一个子任务，立刻 /compact。每切换一个任务，立刻 /clear。

这一个习惯，就能帮你省下 50% 以上的 Token。

💡 本系列全程使用 weelinking 访问 Claude， 国内可稳定使用

如果这篇文章帮你省了钱，点赞收藏让更多人看到！

有问题欢迎评论区讨论，我会及时回复！

关注我，获取更多 AI 开发实战技巧！