搞懂 Token，AI 账单至少省一半

“ 阅读本文大概需要 3.9 分钟。

前段时间，很多道友反馈说，各种 AI 工具 token 消耗太快了，那么答应大家的，我要写篇文章，今天兑现。

本文先详细给大家解释 token 的概念，然后给大家一些优化 token 消耗的真实有用的干货建议。

可以说，今天这篇，我把 Token 从底层逻辑到实操省钱，一次性讲透，建议大家逐字阅读。

1、Token 到底是什么

先说结论：Token 不是字，不是词，而是 AI 的最小阅读单位。

人类读文章，眼睛不是一笔一划扫的，而是以词组为单位跳着看。AI 也一样，它不逐字处理，而是把文本切成一块一块的「Token」来理解。

这个切法，用的是一种叫 BPE（字节对编码）的算法。你不需要记这个名字，只需要知道它的核心逻辑：

出现频率越高的词，越倾向于整个作为一个 Token；越罕见的内容，越会被拆成碎片。

举几个例子你就懂了：

• 英文单词 hello，出现频率极高，整个就是 1 个 Token

• 英文单词 indescribable，比较生僻，会被拆成 in + describ + able，3 个 Token

• 中文「你好」，2 个 Token（中文基本一个字一个 Token，偶尔两个字合成一个）

• 中文「鳎鹚鹨」，3 个字可能变成 6-9 个 Token，因为太罕见，每个字都要拆成字节级碎片

看出规律了吗？

同样的语义，表达方式不同，Token 数量可以差好几倍。 这直接决定了你花多少钱。

还有一个反直觉的事实：代码里的空格、换行、括号，全都是 Token。一个格式优美但缩进层级很深的代码文件，Token 数可能比压缩版多出 30-40%。

讲到这里，很多人会问一个问题：中文是不是比英文更费 Token？

直觉上好像是——中文一个字就是一个 Token，英文一个常见单词也是一个 Token，但一个英文单词表达的信息量比一个汉字多得多。

答案是：确实更贵，但没有想象中那么夸张。 以 GPT-4o 的 Tokenizer 为例（不同模型的切分方式略有差异，但整体规律一致），每个色块就是一个 Token：

同样一句「我很喜欢这个应用」，英文 4 个 Token，简体中文 5 个，繁体中文直接飙到 8 个。

为什么？看切分细节就明白了：英文的 love、this、app 都是高频词，各占 1 个 Token。简体中文的「喜欢」「这个」「应用」也是常见词组，被合并成了单个 Token。但繁体的「喜歡」被拆成了「喜」+「歡」，「這個」被拆成了「這」+「個」，「應用」被拆成了「應」+「用」——每一个都被打散了。

所以一般来说：英文最省，简体中文稍贵，繁体和生僻词最贵。 核心原因是训练数据中的词频——出现越多的词越容易被合并成一个 Token，出现越少的就越碎。

当然这不是绝对的，因为这还取决于大模型训练的语料，比如同样的中文句子，在国外模型和国产模型就会有差异，因为国产模型中文语料是最大最全也最重视的，不过随着中文用户群体的持续增长，现在很多国外模型也都比较重视中文语料的训练了。

这就是 Token 的计费逻辑——不是按你说了多少话，而是按 AI 需要处理多少碎片。

2、Token 背后的经济学

知道了 Token 是什么，接下来聊一个更实际的问题：为什么 AI 按 Token 收费？

因为每一个 Token，都要经过模型全部参数的计算。

以 Claude Opus 为例，模型参数量在千亿级别。你发给它的每一个 Token，都会在这些参数之间「走」一遍。Token 越多，计算量越大，GPU 烧的时间越长，成本就越高。

所以 Token 就是算力的代名词。按 Token 收费，本质上就是按算力收费。

| 输入贵还是输出贵？

答案是输出贵得多。

以 Claude 系列为例（单位：每百万 Token）：

• Haiku：输入 $1 / 输出 $5

• Sonnet：输入 $3 / 输出 $15

• Opus：输入 $5 / 输出 $25

输出价格是输入的 5 倍。原因很简单：输入 Token 可以并行处理（一次性全看完），但输出 Token 必须逐个生成——每生成一个字，都要基于前面所有已生成的内容来推算下一个字。这个串行过程，计算量比并行大得多。

所以一个原则：让 AI 少说废话，比你少打几个字更省钱。

| 上下文窗口：不是记忆力，是视野

很多人以为「200K 上下文窗口」意味着 AI 能「记住」20 万 Token 的内容。

更准确的理解是：它一次能「看到」多少内容。

就像你桌上摊开一本书，上下文窗口就是你桌子的大小。桌子越大，你能同时翻开的页数越多，但处理每一页的工作量也越大。

这意味着：上下文越长，单次请求的计算量越大，成本也越高。

| 你看不见的隐性 Token

这是大多数人忽略的盲区。

你以为自己只发了一句「hello」只消耗一个 token 么？实际上 AI 处理的远不止这些：

• 系统提示词：每次对话都会带上，通常几千 Token

• 对话历史：你和 AI 聊了 20 轮，每一轮的内容都在

• 工具描述：如果 AI 能调用搜索、代码执行等工具，这些工具的定义也会带上

• 项目文件：在 AI 编程工具里，你打开的文件、项目配置都可能被塞进上下文

一条简单的消息，背后可能附带了几万 Token 的「隐形行李」。而这些，全部要付费。

3、Agent 时代，Token 消耗变了

如果说传统的 AI 聊天是「你问一句、它答一句」，那 AI Agent 就是「你下一个指令、它自己干一整套」。

这带来了 Token 消耗逻辑的根本变化。

| 传统聊天 vs Agent

传统聊天：你发 100 Token → AI 回 500 Token → 花了 600 Token，完事。

Agent 模式：你发 100 Token → Agent 先思考要怎么做 → 读了 5 个文件（花 12000 Token） → 分析代码结构（思考花 8000 Token） → 写了一版代码 → 跑测试发现有错 → 修改代码 → 再跑测试 → 通过 → 回复你结果。

一个简单的指令，Agent 内部可能转了十几轮，每一轮都带着完整上下文。

这就是为什么很多人第一次用 Claude Code 时吓一跳：「我就让它改个 bug，怎么烧了几十万 Token？」

| 滚雪球效应

Agent 的 Token 消耗有一个显著特征：滚雪球。

第 1 轮：系统提示 + 你的指令 = 5000 Token

第 2 轮：上面 5000 + AI 的回复 + 读取的文件 = 15000 Token

第 3 轮：上面 15000 + 新的操作和结果 = 30000 Token

每一轮都要把前面所有内容再处理一遍。这就是为什么一次长会话下来，Token 消耗可以轻松到几十万甚至上百万。

有个开发者分享了一个极端案例：49 个子任务并行跑了 2.5 小时，估计花了 8000 到 15000 美金。

不理解 Token，你就不理解账单。

4、所有 AI 用户都该知道的基础优化

不管你用什么 AI 工具，这几条建议都适用。

| 让 AI 少说废话

很多人在第一次使用 AI 工具的时候，AI 在处理任务的时候会附带一堆碎碎念，其实这些都是消耗 token 的。

这就好比，一个人在吃饭，每吃一口饭，每夹一个菜都要告诉全世界。

如果你是新手这些碎碎念便于你理解 AI 思考和处理任务的过程，但是上手之后就把它关了。

在提示词里加一句「不要解释，直接给结果」或「Skip the preamble」，可以减少 30-50% 的输出 Token。

别小看这个。输出 Token 价格是输入的 5 倍，AI 每多说一句客套话，你都在为它的「礼貌」买单。

| 精准表达，避免模糊提问

向 AI 提需求，尽量精准表达。不要说「帮我写一篇周报」——AI 再强大，也猜不到你这周干了什么，只会给你一堆废话模板，来回几轮才能改成你要的样子。

你应该告诉它：「帮我写一篇本周工作周报，主要做了三件事：1. 完成了用户登录模块的重构；2. 修复了支付页面的金额计算 bug；3. 参加了新项目的需求评审。风格简洁，每条两三句话就行。」

一次说清楚，一次出结果。 模糊提问导致的来回纠错，是最隐蔽的 Token 浪费——每一轮修正都带着前面所有对话的上下文成本。

| 同类需求，整合一次输入

很多人虽然用了全球最顶端的 AI 工具，但是使用方式还是对话式聊天，问一句答一句。

前面说了，哪怕你问个「hello」，都会消耗很多 token，所以现如今的 AI 工具，token 消耗瓶颈不在输入端，这时候要学会合并信息。

比如：帮我查询下 xxx 数据，整合成一份报表，以 pdf 形式保存在我桌面。

这三个需求比你聊天式问 AI 三次节省很大 token。

| 结构化输出限制

前面说了，AI 的输出是最贵的，所以限制输出是很必要的。

最简单的方式：告诉 AI 你要什么格式、多长。

比如你让 AI 做竞品分析，不加限制它可能洋洋洒洒写 2000 字。但你其实只需要一个表格：

「帮我对比 Claude Code，Codex，Cursor 这三个工具，从价格、模型支持、上下文窗口三个维度，用表格输出，每格一句话。」

同样的信息量，表格可能只有 200 Token，长文要 1500 Token。输出格式不同，成本差 7 倍。

常用的限制技巧：

• 「用表格输出」——比自然语言省 3-5 倍

• 「每条不超过两句话」——防止 AI 展开论述

• 「只列要点，不要解释」——砍掉最占 Token 的部分

• 「回复控制在 200 字以内」——直接设上限

| 选对模型比什么都重要

很多人上来就用最贵的模型，觉得「反正要用就用最好的」。

数据会让你清醒一下：Claude Opus 在 SWE-bench 上的得分是 80.8%，Sonnet 是 79.6%。差距只有 1.2 个百分点，但 Opus 贵了约 67%。

处理文本信息，用 DeepSeek 完全够用，而且非常便宜。

日常对话、写文章、改改代码，Sonnet 甚至 Haiku 就够了。

Opus 留给真正需要深度推理的复杂任务。

| 学会和一些免费工具结合

这里拿我的 news.stormzhang.ai 网站举例子，很多人第一印象是我这个网站要抓取数据，又做了 AI 智能分析，肯定很耗 token 吧。

如果你理解了 token 的底层机制，就知道抓取数据我走的一些免费爬虫代理，AI 只是调用而已，我爬虫不会抓取页面的整个数据喂给 AI 的，那成本肯定扛不住，我只抓取了网页的信息摘要，比如 title、summary，时间，标签之类的，然后把这些摘要信息再喂给 AI 做翻译和分析，消耗 token 极少。

所以，如果你想翻译几十篇文章，那不要直接丢给 AI，你直接用免费的 Google 翻译就可以搞定。这里额外提下，AI 领域号称的「御三家」，我唯独 Google 没付费，因为 Google 的很多工具和产品免费基本都够用了。

| 不要上来就让 AI 去写代码

很多人在用 AI 做项目的时候，很快就让 AI 开始写代码了，其实代码是极其耗费 token 的，所以每个人在做项目之前，一定要先做个项目整体规划，一步步做好 plan，都确定之后再让 AI 写代码。

| 要 diff 不要全文

改代码时，告诉 AI「只给我修改的部分，用 diff 格式」。一个 500 行的文件，可能只改了 10 行，但如果你不说，AI 会把整个文件重新输出一遍。

差距是 50 倍。

| 先要最小实现

「先给一个能跑通基本场景的最简版本，不要处理边界情况。」

然后再逐步迭代。这比一次让 AI 生成一个「完善」的大块代码，总 Token 消耗反而更少——因为你避免了生成大量你可能不需要的代码。

| 方向错了立刻停

跟 AI 来回扯了三四轮还没解决？停下来，重开一个对话。

继续在错误的方向上追加，每一轮都在为之前所有的错误上下文买单。重新开始反而更省。

| 理解 Prompt Caching

这是一个大多数人不知道的隐藏福利。

Claude 和 GPT 都有缓存机制：如果你连续对话中，前面的内容（系统提示、工具定义等）没有变化，这部分 Token 会命中缓存，只收正常价格的 10%。

但缓存有个 5 分钟的有效期——超过 5 分钟没发消息，缓存就失效了，下一次请求又要全价重新计算。

所以如果你在用 AI 工具干活，保持一定的对话节奏，不要中间去泡个茶回来发现缓存全过期了。

| 不要安装过多的 skills 和插件

很多新手一般都是看到新出来一个好用的开源工具，第一时间就安装。装完之后可能就用了一两次，然后再也没碰过，但它一直挂在那里。

问题在于，每个 Skill 和插件安装之后，它的完整定义会被注入到系统提示词里——也就是我们前面说的那些「隐性 Token」。

举个例子，一个 Skill 包含名称、触发条件、使用说明、参数描述等信息，少则几百、多则上千 Token。你装了七八个 Skill，光这些定义就可能多出 3000-5000 Token。

关键是，这些 Token 每一轮对话都要带上，不管你这轮用不用得到这个 Skill。你问一个简单的问题，后台照样把你装的所有 Skill 定义全部塞进上下文。

所以建议是：

• 定期清理不再使用的 Skill 和插件，别让僵尸工具吃你的 Token

• 功能重叠的只留一个，不要同时装三个类似功能的插件

• 用的时候再搜索安装，你放心，用的时候你一定找得到

• 只有部分项目单独用到的就不要全局安装

少即是多。装得越少，每轮对话的底座消耗越低，留给真正有用内容的空间就越大。

5、Claude Code 深度优化指南

这部分写给 AI 主力是 Claude Code、Codex 重度用户，可能相当大部分是程序员。Codex 几乎和 CC 没多大差异，如果你是 Codex 用户，可以直接把下方内容粘贴给 Codex，去逐个了解检查就好。

| 上下文管理：最核心的杠杆

● 理解你的启动成本

Claude Code 还没开始干活，光是加载基础环境就占了大约 8000 Token：

• 系统提示词：~4200 Token

• 项目 CLAUDE.md：~1800 Token

• 全局配置：~320 Token

• 环境信息：~280 Token

• MCP 工具描述：~120 Token

• 其他（Skill、Memory 等）：~1000+ Token

这些是每一轮对话都要带上的「底座消耗」。所以你的 CLAUDE.md 写了 5000 Token？恭喜，每轮对话的固定成本直接翻倍。

所以尽量让你的系统 CLAUDE.md 别太大，尽力保持精简些。

不过 Claude Code 默认开启了缓存，第一次是全部 token 消耗，之后 CLAUDE.md 默认就会走缓存。

● `/clear` 是最重要的习惯

切换任务时，一定要 /clear。

你从「改登录页面」切到「重构数据库模型」，之前所有关于登录页面的上下文——读过的文件、改过的代码、来回的讨论——全都还在，每一轮都在为这些无关内容付费。

/clear 一下，清清爽爽重新开始，等同于你开启一个新窗口。

● `/compact` 主动压缩

不要等上下文快满了（95%）才触发自动压缩。在完成一个子任务后就手动 /compact，建议 60-70% 时触发。

而且可以加指令：/compact Focus on code changes and test results——告诉它保留什么、丢掉什么。

● `/btw` 顺便问问

有时候你想问个小问题，但又不想让它进入正式对话历史。

用 /btw，答案会显示在弹窗里，不进入上下文。问完即走，不膨胀你的 Token 消耗。

● `/context` 诊断浪费

执行 /context 可以看到当前上下文里每个元素占了多少 Token。你会发现，真正的浪费往往不在你写的提示词里，而是藏在累积的工具输出和读取的文件内容中。

| 项目配置：一次设置，长期受益

● `.claudeignore` 必须有

语法跟 .gitignore 一样，用来告诉 Claude Code 哪些文件和目录不要读取、不要加载到上下文里。

比如你项目里有大量日志文件、测试数据、图片素材、node_modules 等，Claude Code 在分析项目时可能会把它们读进来，白白占用 Token。在 .claudeignore 里声明之后，这些文件就会被跳过，大约能节省 30-40% 的上下文消耗。

*.log

*.png

node_modules/

.next/

dist/

coverage/

__pycache__/

*.pyc

build/

仅加一个 .next/ 就能减少 30-40% 的上下文消耗。这是投入产出比最高的单一优化。

● CLAUDE.md 控制在 200 行以内

CLAUDE.md 是每轮对话都要加载的「固定税」。它越长，你的每条消息成本越高。

该放的：

• 不读代码猜不到的构建命令

• 与默认不同的代码风格规则

• 项目特有的架构决策和常见坑

不该放的：

• 读代码就能推断出来的东西

• 标准语言惯例（Claude 已经知道）

• 详细 API 文档（改用链接）

• 「写干净代码」之类的废话

● 专项指令移入 Skills

CLAUDE.md 里关于 PR review、数据库迁移等特定工作流的详细说明，移到 Skills 文件中。不调用时不加载，调用时才进入上下文。

● 精简 MCP Server

每个 MCP 工具的定义都会注入 system prompt。你装了 10 个 MCP Server 但日常只用 2 个？另外 8 个的工具描述每轮都在消耗 Token。

用 /mcp 禁用不活跃的 Server。能用 CLI 命令（gh、aws、gcloud）完成的事，优先用 CLI——它们不增加每轮请求的固定开销。

● 善用 ！bash

在 Claude Code 对话框里输入 ! 命令（感叹号 + 空格 + 命令），可以直接在当前会话里执行 shell 命令，输出会自动进入对话上下文。

这有什么用？举个例子，你想让 Claude 分析一段日志，正常做法是 Claude 自己去读文件、调工具，每一步都要消耗 Token。但如果你直接 ! tail -100 app.log，日志内容一次性进入上下文，Claude 不需要再额外调用工具去读取。

更实用的场景：

• ! git log --oneline -20——让 Claude 直接看到最近的提交记录，不用它自己去执行

• ! cat package.json——把配置丢进来，比让 Claude 用 Read 工具省一轮工具调用

核心逻辑是：你主动喂精准的信息，比让 Agent 自己去摸索，省的不止是 Token，还有来回试探的轮次。

● Hooks 预处理长输出

Hooks 你可以理解为「拦截器」——在 Claude 执行某个操作之前或之后，自动跑一段你预设的脚本。

这跟省 Token 有什么关系？举个最常见的场景：

你让 Claude 跑一次测试，测试输出了 5000 行日志，其中 4990 行是 PASS，只有 10 行是 FAIL。如果不做处理，这 5000 行全部塞进上下文，白白吃掉几万 Token。

有了 Hook，你可以设置一个规则：在测试结果进入上下文之前，自动过滤，只保留 FAIL 和 ERROR 的行。 5000 行变 10 行，万级 Token 缩到百级。

再比如，Claude 每次改完代码，你希望自动跑一下代码格式化工具。没有 Hook 的话，Claude 可能要花好几轮跟你讨论格式问题；有了 Hook，改完自动格式化，省掉了不必要的来回。

简单说：Hook 就是帮你在 AI 的操作流程中插入自动化脚本，把不必要的信息拦在上下文之外。

| 执行策略：怎么干活更省

● Plan Mode 先规划再执行

Shift+Tab 进入 Plan Mode。Claude 只读文件、回答问题，不做任何修改。

等计划确认了再执行。防止走错方向导致的昂贵返工。

这不是效率低——一次规划准确落地，比试错三次的总 Token 消耗低得多。

任何新项目开始都应该走 plan 模式。

● `/effort` 调节思考深度

Claude 的「思考过程」（Extended Thinking）也是按输出 Token 计费，默认预算可达数万 Token。

改个变量名需要思考这么久吗？不需要。

• 简单任务：/effort low

• 日常开发：/effort medium

• 复杂架构：/effort high

也可以设置环境变量 MAX_THINKING_TOKENS=10000 全局限制。

● 按任务切模型

用 /model 随时切换：

• 日常编码：Sonnet（性价比最高）

• 复杂架构分析：Opus（最强但贵约 67%）

• 批量简单任务：Haiku（最快最便宜）

在 .claude/settings.json 中设置

"CLAUDE_CODE_SUBAGENT_MODEL" : "haiku"，让子代理默认用便宜模型。

● Subagent 隔离上下文

让 Claude 用 Subagent 做调查性工作：「用子代理去调查 auth 模块是怎么处理 token 刷新的」。

Subagent 在独立的上下文窗口运行，可能读了 6000 Token 的文件，但只返回 400 Token 的摘要给主对话。主上下文只增加 400 Token，而不是 6000。

● 精确指定文件和行号

「看看 src/auth/session.ts 第 30-90 行」，而不是「看看 auth 相关的代码」。

后者会触发文件搜索，读一堆可能无关的文件，每个文件几千 Token。前者精准定位，一步到位。

● Rewind 撤回错误轮次

前面基础优化里说了「方向错了立刻停，重开对话」。但在 Claude Code 里有更精细的操作——Rewind。

Claude 执行了一步但结果不对？不用 /clear 把整个对话扔掉，按两下 Esc 触发 Rewind，直接撤回上一轮操作。代码改动会回滚，那一轮的上下文也会从对话历史中移除。

这意味着后续每一轮都不用再为那次错误买单。比重开对话省，因为之前正确的上下文还在；比硬撑着继续省，因为错误不会滚进雪球。

● 一个任务一个会话

「重构用户模型」「重构认证路由」「更新 API 测试」——拆成三个会话分别做。

不要在一个会话里塞太多不相关的任务。上下文越长，每轮的边际成本越高，而且 AI 的注意力也会分散，质量反而下降。

● 给验证目标而非模糊指令

「加个验证」→ Token 低效：Claude 猜你想要什么，可能来回几轮。

「为无效邮箱格式写一个测试用例，然后让测试通过」→ Token 高效：目标清晰，一次到位。

模糊的指令是最贵的指令。

● 学会给 Claude Code 写交接文档

如果你有一个长任务，一个会话搞不定这个任务，你需要分多个会话完成时，让 Claude 在当前会话结束前写一份 300 字以内的交接摘要——做了什么、关键决策、下一步计划。

下次新会话直接把这个摘要丢给它，避免重新探索整个代码库的开销。

6、最后

Token 这个概念，说大不大，说小不小。

不理解它，你用 AI 就像开车不看油表——不知道钱花在哪儿，不知道怎么花更少。

理解它，你会发现很多看起来「省小钱」的优化，累积起来效果惊人。一个合理的 .claudeignore 加上主动 /compact 的习惯，就能让同样的预算多干 40-50% 的活。

AI 时代的核心能力，不只是会写提示词，还包括理解你用的工具是怎么计费的。

Token，就是你和 AI 之间的货币。花得明白，才用得值。