Claude Code越用越贵？5个技巧让成本降70%

你有没有发现，用 Claude Code 写代码，刚开始很便宜，但聊着聊着账单就上去了？

有些开发者可以使用一整天，而有些人却只能用 3 小时就耗尽了额度。

问题不在于工具贵，而在于你不知道Token是怎么算的。

Token到底是什么？

Token是AI的计价单位

Token是AI处理文本的基本单位，也是计费单位。简单理解：Token就是AI的"燃料"，用多少烧多少钱。

换算关系很简单：

• • 1,000 Token ≈ 750个英文单词
• • 1,000 Token ≈ 500个汉字
• • 1行代码 ≈ 5-15 Token

模型按照输入（Prompt）和输出（Completion）的 Token 数量计费。

输出比输入贵5倍

Token分两种：

• • Input Token：你发给AI的内容（提示词、代码、上下文）
• • Output Token：AI生成的内容（代码、解释、回答）

关键来了：Output Token的价格是Input的5倍。

以Claude Sonnet 4.5为例：

• • 输入：$3/百万Token
• • 输出：$15/百万Token

这意味着什么？让AI说废话，是最昂贵的浪费。

什么是上下文

Context Window 是模型能处理的上下文长度上限，以 Token 为单位。

超出上限会自动压缩：当上下文接近或超出限制时，模型会自动压缩早期的对话内容，保留最新和最相关的信息。这可能导致部分历史细节被简化或忽略。

上下文"滚雪球"效应

每次对话，Claude Code 都要带上之前的历史记录。聊得越久，每句话的成本越高。

你以为你只问了"改个颜色"，实际上 Claude 读取了整个项目的上下文。

上下文越大，每次交互的成本越高。如果你不主动管理，Claude会一直记着你3小时前调试的那个Bug。

花费是从哪里来的？

核心理解：

• • 单次调用很便宜，但累积起来也是钱
• • 上下文越大 = 花费越高：读取整个项目 vs 只读一个文件，差异是数量级的
• • 频繁调试时要注意：循环修改会不断累积 Token

基于以上核心逻辑，就不难掌握接下来的省钱技巧了。

5个省钱技巧

技巧1：精准定位

❌ 错误示范：

"帮我看看登录功能有什么问题"

✅ 正确示范：

查看 src/auth/login.ts 有什么问题？

区别在哪？前者让Claude扫描整个项目，后者直接定位到具体文件。

效果：减少80%冗余文件扫描。

精准描述的公式

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

实例：

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

告诉 Claude 不要做什么

主动限制 Claude 的行为范围，能大幅减少不必要的 Token 消耗。

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

常用限制语及效果：

限制语	效果
"不需要解释"	减少 500-2000 输出 tokens
"只修改这个文件"	避免 Claude 连带改其他文件
"不需要写测试"	省去测试代码的生成
"简洁回复"	整体输出减少 30-50%
"不要读取其他文件"	阻止不必要的文件读取
"只看这个函数"	避免读取整个文件

技巧2：定期"洗脑"

Claude Code提供了三个命令：/context、/compact 和 /clear。

使用 /context 查看 Token 占用

在优化之前，先要知道 Token 都花在哪了。

/context

这个命令会显示当前对话的 Token 使用情况，包括：

• • 系统提示词占用
• • 对话历史占用
• • MCP 工具占用
• • 项目文件（CLAUDE.md）占用

操作步骤：

1. 1. 每完成一个独立任务，运行 /context 查看当前占用
2. 2. 若超过50%，运行 /compact 并指定保留内容
3. 3. 若开启完全不同的任务，果断 /clear

/compact：有损压缩

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

# 基础用法
/compact

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

效果对比：

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

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

节省：88%

最佳使用时机：

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

/clear：彻底清空

/clear 是彻底清空，直接归零。当你完全切换任务时使用。

什么时候用 /clear：

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

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

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

效果：长会话成本降低50%-70%。

避坑提示：不要让Claude带着"调试A的痛苦记忆"去开发"功能B"。

技巧3：规则前置

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

在项目根目录创建一个 CLAUDE.md 文件，把项目规范、常用路径、避免使用的库写进去。

Claude Code会自动读取这个文件。这样你就不用每次在Prompt里重复输入500字的背景介绍了。

示例配置：

# CLAUDE.md

## 项目概述
这是一个 Next.js 全栈项目，使用 App Router，PostgreSQL 数据库。

## 技术栈
- Next.js 14 (App Router)
- React 18
- Tailwind CSS (样式)
- Prisma (ORM)
- PostgreSQL 15

## 项目结构
- app/         → 路由与页面组件
- components/  → 可复用 UI 组件
- lib/         → 工具函数与数据库客户端
- prisma/      → 数据库 schema

## 编码规范
- 组件默认使用 Server Components，客户端交互添加 "use client"
- 样式统一使用 Tailwind CSS 工具类
- 所有的 API 请求通过 Server Actions 处理

## 常用命令
- 本地开发：npm run dev
- 构建产物：npm run build
- 数据库迁移：npx prisma db push

为什么这样做能省 Token？

没有 CLAUDE.md 时：
  你："这是一个 Next.js 项目，用的 App Router..."    → 每次都要说，50 tokens × N 次
  你："不要用 Pages Router，要用 Server Actions..."  → 每次都要说，40 tokens × N 次
  你："样式必须用 Tailwind CSS 编写..."              → 每次都要说，30 tokens × N 次

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

.claudeignore：让 Claude 别看不该看的

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

在项目根目录创建 ：

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

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

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

# 资源文件
*.png
*.jpg
*.gif
*.svg
*.ico

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

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

# 大型数据文件
*.csv
*.jsonl
data/

效果有多明显？

一个典型的 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/ 和配置文件 → 精准高效

原理：一次性告诉 Claude 项目规则，避免重复消耗 Token。

技巧4：善用缓存

缓存机制：5分钟窗口期

Claude API 有个隐藏机制：5分钟缓存窗口期。

在 5 分钟内，如果你的上下文（系统提示、MCP 工具、CLAUDE.md 等）没有变化，后续请求会命中缓存。虽然为了生成缓存结构需要一次性增加少许“写入成本”，但随后长达 5 分钟的频繁交互中，缓存命中带来的红利足以让后续 Token 读取价格骤降至原价的 1/10。

缓存命中时，Token 读取价格仅需原价的 1/10：

• • 正常输入：$3/百万Token
• • 缓存读取：$0.3/百万Token

优化建议：

• • 尽量连续操作，避免超过 5 分钟的间隔
• • 保持上下文稳定，不要频繁修改 CLAUDE.md 或切换 MCP
• • 分阶段规划，阶段间间隔控制在 5 分钟以内

技巧：短时间内解决关联问题。

比如，你需要修复 3 个相关的 Bug，请不要分三次开启新会话。一次性把 3 个需求发过去，利用缓存红利。

实测：在一个5,000行的项目中频繁运行单元测试，保持会话开启。后续10次交互，总成本仅为未缓存时的15% 。

技巧5：Plan Mode——先规划后执行

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

什么是 Plan Mode

Plan Mode 是 Claude Code 的规划模式，按 Shift+Tab 进入。在这个模式下，Claude 只读取必要文件、只输出方案，不写代码。

等你确认方案后，再退出 Plan Mode 执行。

没有 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.js
        3. 涉及文件：middleware/auth.js, routes/userRoutes.js, controllers/userController.js
        你觉得这个方案如何？

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

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

核心原理

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

最佳使用场景：

• • 功能开发（不确定具体实现方式）
• • 架构设计（需要先对齐方案）
• • 大规模重构（涉及多个文件）
• • 复杂的 Bug 修复（需要先定位问题）

效果：节省 40-78% 的 Token 消耗。

真实案例：同一个任务，成本差6倍

让我们看一个真实的对比案例：为一个 Next.js (App Router) 项目引入并配置 NextAuth 进行路由鉴权。

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

第1轮："帮我全站加个 NextAuth 登录拦截"
  → Claude 扫描整个项目结构（尝试读取大量的 app/ 结构及核心组件）
  → Claude 输出详细的方案并生成大量代码
  → 输入: 30000 tokens, 输出: 2000 tokens

第2轮："不对，我要用的是 Credentials Provider 方案，不是官方默认的例子"
  → Claude 重新读取文件，重新生成代码
  → 输入: 35000 tokens, 输出: 3000 tokens

第3轮："中间件放错位置了，应该放在项目根目录 middleware.ts"
  → Claude 再次调整，由于未清洗上下文，文件阅读记录继续膨胀
  → 输入: 40000 tokens, 输出: 1500 tokens

第4轮："未登录状态下，把自动重定向改到 /auth/signin 页面"
  → 上下文不仅累积了多次历史方案，还有多份代码结构
  → 输入: 45000 tokens, 输出: 2000 tokens

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

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

准备工作：
  ✅ 项目已有 CLAUDE.md（写明了 Next.js 版本及鉴权技术栈规范）
  ✅ 已配置 .claudeignore（已排除 node_modules 等文件夹的干扰）

第1轮：[使用 Plan Mode]
"在项目根目录新增 middleware.ts 添加全站路由拦截；
并在 app/api/auth/[...nextauth]/route.ts 配置 Credentials Provider。
只需要保护 /dashboard 开头的路由。
先出方案不要写代码。"

  → Claude 只提取和阅读上述几个核心文件
  → 输出简短方案
  → 输入: 5000 tokens, 输出: 800 tokens

第2轮："方案验证 OK，请按照方案实现代码。"
  → Claude 精确实现
  → 输入: 8000 tokens, 输出: 2000 tokens

/compact  (核心：清理前两轮冗长的沟通和发散的知识库)

第3轮（如果要微调）："修改 middleware.ts，将未授权跳转地址改为 /auth/signin"
  → 输入: 4000 tokens, 输出: 300 tokens

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

对比结果

维度	程序员 A	程序员 B	差距
总输入 Token	150000	17000	8.8倍
总输出 Token	8500	3100	2.7倍
总成本	$0.58	$0.098	5.9倍
对话轮数	4轮（含两次大返工）	2-3轮（精准执行）	-
最终效果	完成	完成	一样

同样的结果，成本差不多差了6倍。日积月累，这绝对是一笔不小的费用。

掌握这些，你的Token会更值钱

Token管理不是限制创造力，而是更高效地使用工具。

下次用Claude Code时，试试这5个技巧：

1. 1. 精准定位：指定文件路径 + 告诉 Claude 不要做什么
2. 2. 定期洗脑：/context + /compact + /clear
3. 3. 规则前置：创建 CLAUDE.md + .claudeignore
4. 4. 善用缓存：一次性解决关联问题（5分钟窗口期）
5. 5. Plan Mode：先规划后执行

核心心法

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

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

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

记住一个终极建议：

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

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