建议全文背诵，读完感觉自己之前在瞎用！

Maximizing the value of your Claude Code sessions

Lydia Hallie · 2026年8月14日 · 译自 https://claude.com/blog/maximizing-the-value-of-your-claude-code-sessions

TL;DR先说这几条

1. Run /clear between tasks. This prevents prior irrelevant context from being sent back to the model, which can reduce token usage.1. 换任务之前先跑一遍 /clear。上一摊不相干的上下文就不会再送回模型，token 用量能下来。

2. Set your model and effort level before you start. Changing either one mid-conversation can bust your prompt cache, which can increase token cost.2. 开干之前先定好模型和 effort。聊到一半再改，prompt cache 会被打穿，费用反而上去。

3. @-mention files instead of naming them. The file gets attached to your message directly, which saves a Read call, or a search if Claude has to go find it.3. 文件用 @ 提，别只写名字。文件会直接挂在这条消息上，少一次 Read，也省得 Claude 自己去翻。

4. Add quiet flags to noisy commands, or run them in a subagent. Command output is added to the conversation just like a file, and stays there for the rest of the session.4. 吵的命令加上安静参数，或者丢给 subagent 跑。命令输出会像文件一样写进对话，一直待到这次会话结束。

5. Run /context once in a fresh session. It shows what's loaded (CLAUDE.md, MCP tool definitions), so you can cut out anything unnecessary.5. 新开一个会话，先跑一次 /context。它会告诉你现在装了什么（CLAUDE.md、MCP 工具定义），用不着的可以拿掉。

6. /compact before you take a break from your keyboard. The prompt cache expires after an hour, and summarizing a conversation is much cheaper while it's still cached.6. 离开键盘之前先 /compact。prompt cache 一小时就过期，趁还在缓存里做摘要，便宜得多。

Maximizing value怎么才算值钱

Until pretty recently, the tools you wrote code with were a flat fee (or free). Your editor cost the same whether you fixed one test or fifty that afternoon, so an individual task didn't really have a price of its own.就在不久以前，写代码用的工具还是一口价（或者干脆免费）。下午修一个测试和修五十个，编辑器花的钱一样，单件任务本身几乎没有价格。

With agentic coding tools like Claude Code, it does. The same completed task can also cost different amounts depending on how you use it.到了 Claude Code 这种 agentic 编程工具，就不一样了。同一件做完的事，用法不同，花的钱也可以差一截。

In one session, Claude reads the test and the file it covers, makes the edit, and is done in a handful of turns. In another, it greps around the repo first, reads a dozen files on its way to the same two, and every one of those turns also drags along everything else that's been read into the conversation since this morning.有的会话里，Claude 读了测试和被测文件，改完，几轮就结束。另一次，它先在仓库里 grep 一圈，读了十来个文件才摸到那两个，而每一轮还会把今早读进对话的东西全拖着走。

It's the same fix, but you spent a different number of tokens on it, and the whole time the model was also having to think about ten files it didn't need.修的是同一处，花的 token 却不一样，而且模型全程还在想那十个它根本不需要的文件。

Being efficient with tokens doesn't mean using fewer of them overall. It means making sure the ones you do use go towards the thing you actually asked for.省 token 不是说总体用得越少越好。是要保证你用掉的那些，真的花在你要的事情上。

So let's look at what decides the price of a token, then what decides how many of them a session sends, and along the way, what that means for how you run a session.那我们先看一个 token 的价钱是怎么定的，再看一次会话会发出多少个，顺带说说这对你怎么开会话意味着什么。

What decides the price of a token一个 token 的价钱怎么定

You're billed per token, but what you're actually paying for is inference: the time it takes a GPU (or a TPU, or whatever the model happens to be running on) to run the model over your tokens.账单按 token 算，但你真正买的是推理：GPU（或者 TPU，或者模型当时跑在什么上）把模型跑过这些 token 所花的时间。

Three things decide how much of that time a token takes: which model you're running, whether it's an input token (going in) or an output token (coming out), and whether it was cached.一个 token 要占多少时间，取决于三件事：你跑的是哪个模型，它是输入 token（进去的）还是输出 token（出来的），以及有没有命中缓存。

Model模型

A bigger model does more work on both input and output tokens. Which model is worth it for which kind of work is a topic on its own, and we covered it in Choosing a Claude model and effort level in Claude Code.更大的模型在输入和输出 token 上都更费功夫。哪种活该用哪个模型，本身够写一篇，我们在「Choosing a Claude model and effort level in Claude Code」里讲过。

For this post, all you need to know is that everything else we're about to cover gets multiplied by the model's price: use a larger model when the problem is genuinely hard or ambiguous, and a smaller one when the work is routine.这篇只需要记住：后面要讲的所有东西，都会再乘上模型的单价——问题真难或者真含糊时用大模型，日常活就用小的。

Curves are for illustration purposes only. They do not represent real benchmark data.曲线只是示意，不代表真实评测数据。

Input and output tokens输入和输出 token

A request goes through the GPU in two phases, and they cost different amounts.一次请求在 GPU 上走两个阶段，价钱也不一样。

First, during prefill, the model reads your request and context: the system prompt, your CLAUDE.md, your message, and everything that's been added to the conversation since (the files Claude has read and the output of the commands it ran). Those are your input tokens.先是 prefill，模型读你的请求和上下文：系统提示、你的 CLAUDE.md、你这条消息，以及之后加进对话的所有东西（Claude 读过的文件、它跑过的命令输出）。这些是输入 token。

Then, during decode, it writes output tokens: its thinking, the tool calls it makes, and the text you see. This happens one token at a time; a 200-token response is 200 runs of the model, one after the other. Per token, decode keeps the GPU busy for a lot longer, which is why output is priced at roughly 5x input.然后是 decode，它往外写输出 token：思考、它发的工具调用，以及你看到的文字。这是一个 token 一个 token 来的；200 个 token 的回复，就是模型连跑 200 次。按每个 token 算，decode 让 GPU 忙得久得多，所以输出大概是输入的 5 倍价。

A lot of the output tokens in a session are thinking tokens, and how much thinking the model does per turn is what the effort level controls. Like the model, the level you pick with /effort sticks around as your default for the next session too.一次会话里，相当一部分输出 token 是思考 token，每轮想多少，由 effort 级别控制。和模型一样，你用 /effort 选的级别会记住，下次会话还是这个默认。

Tip

run /model and /effort once in a fresh session to see what you're actually on. Both remember whatever you picked last time, and you want that decision to be deliberate.

新开一个会话先跑一次 /model 和 /effort，看看自己实际用的是什么。两个都会记住上次选的，这件事最好是有意选的，别稀里糊涂接着用。

Tip

if you already know a session is going to be grunt work, MAX_THINKING_TOKENS=0 claude turns thinking off for that one session (except on Fable 5), which is the step below /effort low.

要是你已经知道这回就是苦力活，MAX_THINKING_TOKENS=0 claude 会把这一次会话的思考关掉（Fable 5 除外），比 /effort low 还再低一档。

Prompt cachingPrompt 缓存

If a request starts with exactly the same tokens as a request the server just saw, the state for that shared beginning comes out the same, so the server can keep it around from last time and only prefill whatever comes after it. This is called prompt caching.如果一次请求开头的 token 和服务器刚见过的完全一样，那段共享开头的状态也一样，服务器就可以沿用上次的，只 prefill 后面多出来的部分。这叫 prompt caching。

Reading from the cache costs 0.1x the input price, because the server loads the state instead of computing it. Writing tokens into the cache costs a bit more than normal input, up to 2x, since the server also has to hold on to the state afterwards. But the write happens once per token, and the 0.1x reads happen on every turn after it.从缓存读只要输入价的 0.1 倍，因为服务器是把状态载进来，不是重新算。把 token 写入缓存比普通输入贵一点，最高到 2 倍，因为写完还得把状态留着。不过写入对每个 token 只发生一次，后面每一轮都是 0.1 倍的读。

Claude Code manages the prompt cache on every request, there's nothing to turn on. However you can break it, so it's important to know how to avoid these cost spikes.Claude Code 每次请求都会自己管 prompt cache，没什么要打开的。但你能把它弄坏，所以得知道怎么避开这些费用尖峰。

Say we type "fix the failing test in utils.test.ts". Here's what Claude Code sends for it:假设我们打「fix the failing test in utils.test.ts」。Claude Code 会这样发：

1. Claude Code assembles the first request out of the system prompt (tool definitions included), your CLAUDE.md, and your message, and sends it off (input tokens). Nothing is in the cache yet, so all of it gets prefilled and written into the cache.1. Claude Code 把系统提示（含工具定义）、你的 CLAUDE.md 和你的消息拼成第一次请求发出去（输入 token）。缓存里还什么都没有，所以整段都要 prefill，并写入缓存。

2. The model can't fix a test it hasn't seen, so it thinks for a moment and responds with a Read call for utils.test.ts (output tokens). Claude Code reads the file, appends it to the conversation, and sends the whole thing again (input tokens). This time everything from request 1 is read back out of the cache at a tenth of the price, and the only thing prefilled at full price is what's new: the Read call and the file.2. 模型没见过测试没法修，于是想一会儿，回一个对 utils.test.ts 的 Read（输出 token）。Claude Code 读完文件，接到对话后面，再把整段发出去（输入 token）。这时第 1 次请求的内容从缓存里按十分之一的价钱读回来，需要按全价 prefill 的只有新的：这次 Read 和文件本身。

3. Now the model wants the file under test (output). Another Read, another append, and everything goes out again: requests 1 and 2 from the cache, the second file at full price (input).3. 现在模型要被测的那个文件（输出）。又一次 Read，又接一段，再整段发出去：第 1、2 次请求走缓存，第二个文件按全价（输入）。

4. The model responds with an Edit (output). Claude Code applies it, appends the result, and sends everything again. Same story: the Edit and its result are new, everything in front of them is a cache read (input).4. 模型回一个 Edit（输出）。Claude Code 应用它，把结果接上，再整段发送。还是那套：Edit 和它的结果是新的，前面全是缓存读（输入）。

5. The model runs npm test (output). Claude Code appends the test output and sends everything again, with the test output as the only new part (input).5. 模型跑 npm test（输出）。Claude Code 把测试输出接上再发，新的只有测试输出（输入）。

6. The tests pass, and the model responds with a short summary (output). No tool call means nothing to append and no request 6, so we're done.6. 测试过了，模型回一句短摘要（输出）。没有工具调用，就没有东西可接，也就没有第 6 次请求，结束。

That's five requests for one small fix, and every one of them contained the entire conversation up to that point. A typical turn is lopsided: tens of thousands of tokens going in, a few hundred coming out. But only what's new in that turn gets prefilled at full price.一个小修复，五次请求，每一次都带着到那时为止的整段对话。典型的一轮是偏的：进去几万 token，出来几百。但只有这一轮新出现的部分，才按全价 prefill。

That's the whole per-turn bill: cache reads on the history, full input price on whatever's new, and the output price on the response.一轮的账单就是这些：历史上的缓存读、新内容的全价输入，再加上回复的输出价。

This applies on a subscription too. You don't see these prices directly, but the same requests are what draw down your limits.

订阅也一样。你看不到这些单价，但吃额度的就是这些请求。

The cache has to match from the very start of the request forward, and requests always go out in the same order: tool definitions, then the system prompt, then the conversation (with CLAUDE.md at the front of it).缓存必须从请求最开头一路对上，而且请求发出的顺序总是固定的：工具定义，然后系统提示，然后对话（CLAUDE.md 在对话最前面）。

If anything in that prefix changes, everything behind it gets prefilled again. A tool result appended to the end of the conversation is the ideal case, since nothing is behind it. What throws the cache away is anything that changes the request further towards the front, or changes what the cache is keyed on:前缀里任何东西变了，它后面的全部要重新 prefill。把工具结果接到对话末尾是最理想的，因为它后面什么都没有。真正把缓存扔掉的，是改到更靠前的位置，或者改了缓存的 key：

1. /model: every model has its own cache, so on the next turn the entire conversation gets prefilled again at full price. (This includes opusplan, which switches models every time you go in or out of plan mode.)1. /model：每个模型有自己的缓存，所以下一轮整段对话都要按全价重新 prefill。（包括 opusplan，进出 plan mode 每次都会换模型。）

2. /effort: the effort level is part of what the cache is keyed on too, so it's the same story. It's why both /model and /effort ask you to confirm when you switch in the middle of a conversation.2. /effort：effort 级别也是缓存 key 的一部分，所以是同一回事。这也是为什么在对话中间切 /model 或 /effort，它会让你确认一下。

3. Fast mode: also part of the key, and the re-prefill happens at fast mode prices, so if you're going to turn it on, turn it on at the start. (Turning it off again is free, cache-wise.)3. Fast mode：也是 key 的一部分，而且重新 prefill 按的是 fast mode 的价格，所以要用就一开始打开。（再关回去，缓存这边是免费的。）

4. /compact: the conversation gets replaced with a shorter one, so nothing in it matches anymore (the system prompt in front of it survives). Writing the summary itself is cheap as long as the old conversation is still in the cache, so it's a lot cheaper before a long break than after one.4. /compact：对话被换成一段更短的，里面没有任何东西还能对上（前面的系统提示还在）。写这份摘要本身很便宜，前提是旧对话还在缓存里，所以长歇之前做，比歇完再做便宜得多。

5. Time: every turn resets the clock, but the cache expires after an hour on a subscription or five minutes on an API key (ENABLE_PROMPT_CACHING_1H=1 makes it an hour). Come back later than that, and the next turn prefills the whole conversation again. Resuming an old session almost always does too: the cache is usually gone by then, and the system prompt gets rebuilt at launch anyway.5. 时间：每一轮都会把计时清零，但缓存订阅上是一小时过期，API key 是五分钟（ENABLE_PROMPT_CACHING_1H=1 可以改成一小时）。回来得比这晚，下一轮就要把整段对话重新 prefill。恢复一个旧会话几乎也是这样：那时缓存多半已经没了，系统提示启动时还会重建一遍。

None of this means you should never switch models or effort. It means there are cheap moments to do it, the start of a session or right after a /clear, and expensive ones, the middle of a long conversation.这些都不是说你永远不该换模型或 effort。是说有便宜的时机——会话开头，或者刚 /clear 完——也有贵的时机，比如一段长对话的中间。

Tip

if the last few turns went somewhere you don't want to keep, /rewind to just before them instead of running /compact. Rewinding only cuts those turns off the end, so everything before them is still cached and it costs nothing. Compacting rewrites the whole conversation, so it always costs something.

要是最近几轮走偏了、你不想留，与其 /compact，不如 /rewind 到它们之前。回退只是把末尾那几轮剪掉，前面的都还在缓存里，不花钱。Compact 会重写整段对话，所以总会花一点。

What decides how many tokens a session sends一次会话会发出多少 token

The main thing to know here is that nothing gets sent just once. Everything that ends up in the conversation, a file Claude read or the output of a command it ran, gets sent again on every turn after it, for the rest of the session.这里最要紧的一点：没有东西只发一次。凡是进了对话的——Claude 读过的文件，或它跑过的命令输出——之后每一轮都会再发一遍，直到这次会话结束。

It's cached, so each of those re-sends is cheap, but cheap isn't nothing, and it's taking up room in the context the model has to think around on every turn too.这些是走缓存的，所以每次重发都便宜，但便宜不是免费，而且它还占着上下文，模型每一轮都得绕着这些东西想。

That's really the whole cost model of a session: how many tokens end up in the context, how many turns they stay there, and how many contexts you're running at the same time.一次会话的成本模型其实就这些：上下文里最终有多少 token，它们会待多少轮，以及你同时开着几个上下文。

What ends up in the context什么会进上下文

Part of what's in the context is there before you type anything: the tool definitions, the system prompt, CLAUDE.md, and whatever else gets loaded at startup.有一部分在你打字之前就已经在了：工具定义、系统提示、CLAUDE.md，以及启动时加载的其他东西。

Tip

run /context in a fresh session to see what's in there before you've typed anything. Keep CLAUDE.md to specific instructions and move workflow-specific ones into skills, which only get loaded when they're used. If there's an MCP server you don't need in this session, turn it off with /mcp.

新开一个会话先跑 /context，看看你还没打字时里面有什么。CLAUDE.md 只放具体指令，跟某套流程绑定的挪到 skill 里，用到才加载。这次用不到的 MCP 服务器，用 /mcp 关掉。

Nearly everything else that gets added during the session is tool results: the files Claude reads, and the output of the commands it runs.会话过程中再加进来的，几乎都是工具结果：Claude 读的文件，和它跑的命令输出。

How much Claude reads mostly comes down to how much it has to figure out on its own. If you say "the tests are failing", it first has to find out which tests: a grep or two, a few files opened to see which one is relevant, and all of those results stay in the context long after they've stopped being useful.Claude 会读多少，多半取决于它得自己摸清多少。你说「the tests are failing」，它得先搞清楚是哪些测试：grep 一两下，打开几个文件看哪个相关，而这些结果早就不需要了，却还留在上下文里。

"Fix the failing test in utils.test.ts" skips the searching and costs one Read call for the file, and "Fix the failing test in @utils.test.ts" doesn't cost the Read call either.「Fix the failing test in utils.test.ts」能跳过搜索，只花一次读这个文件的 Read；「Fix the failing test in @utils.test.ts」连这次 Read 也不花。

Tip

when you're referring to a file, @-mention it instead of typing the path. Claude Code attaches the file to your message before anything gets sent, so it's in the very first request and there's no Read call for it. The file itself takes up the same room in the context either way, so you only need to mention it once per conversation: it stays there, and @-mentioning it again on a later turn generally attaches a second copy.

提到文件时，用 @ 提，别只打路径。Claude Code 会在发出任何东西之前把文件挂到你的消息上，所以它在第一次请求里就在，不用再 Read。文件占的上下文空间两种写法一样，所以一次对话里提一次就够：它会一直待着，后面再 @ 一次，通常会再挂一份副本。

The other thing that fills up the context is the output of the commands Claude runs. Every time it runs your tests, a build, or a git log, whatever that prints gets appended to the conversation just like a file it read, and stays there for the same number of turns.另一件把上下文填满的，是 Claude 跑的命令输出。每次跑测试、构建，或者 git log，打印出来的东西都会像读过的文件一样接到对话后面，并且待同样多轮。

Really big outputs are actually fine: after 30,000 characters Claude Code writes the output to a file and only puts a short preview and the path in the conversation (BASH_MAX_OUTPUT_LENGTH if you want to change it).特别大的输出其实还好：超过 3 万字符，Claude Code 会把输出写到文件里，对话里只放一段短预览和路径（想改这个阈值用 BASH_MAX_OUTPUT_LENGTH）。

The problem is everything under that. A test runner that prints 400 passing tests one line at a time comes in under the limit, and those 400 lines are now part of every remaining turn.麻烦的是阈值以下的那些。一个测试跑完，一行一个地打出 400 条通过，没超过上限，这 400 行就成了后面每一轮的一部分。

Claude will often take care of this for you with flags and tail, and if you'd rather not leave it up to Claude, there's a small hook in the docs that rewrites noisy commands before they run so only the lines that matter come back.Claude 常常会自己用参数和 tail 处理这件事。要是你不想交给它，文档里有个小 hook，能在命令跑之前改写那些吵的命令，只把要紧的行带回来。

Tip

put the two or three commands you run all day in CLAUDE.md, quiet flags included, the way you'd type them yourself ("run a single test file with npx vitest run <file> --reporter=dot"). It's a small addition, but it saves a turn and a few hundred lines of output in every session after it.

把你成天跑的那两三个命令写进 CLAUDE.md，安静参数也写上，就像你自己会打的那样（「run a single test file with npx vitest run <file> --reporter=dot」）。加的不多，但之后每个会话都能省一轮，再少几百行输出。

How many turns it stays there它会待多少轮

One long session costs more than the same work spread over a few short ones, and by more than you'd think, because turn 40 is also re-reading the 39 turns before it. You want the context in your session to be short and relevant, so don't carry one task's context into the next: /clear when you start something new, and /compact when the earlier part of the same task is done.一个长会话，比把同样的活拆成几个短会话更贵，而且贵得超乎直觉，因为第 40 轮也在重读前面 39 轮。你希望会话里的上下文又短又相关，所以别把上一件事的上下文带到下一件：开新活就 /clear，同一件事的前半段做完了就 /compact。

Tip

/rename before you /clear if you'll want the session back later. When you /compact, tell it what to keep, or put a "Compact instructions" section in CLAUDE.md if it's always the same thing. And if you're on a 1M model and would rather have the auto-compact safety net where it used to be, /autocompact 200k puts it back (needs Claude Code v2.1.221+).

以后还想找回这次会话的话，/clear 之前先 /rename。/compact 的时候告诉它该留什么，或者如果每次都一样，在 CLAUDE.md 里加一节 Compact instructions。如果你用的是 1M 模型，想把以前那个自动 compact 的安全网加回来，/autocompact 200k 就行（需要 Claude Code v2.1.221 以上）。

Keep an eye on turns that happen when you're not typing, too. A /loop fires as a full turn in the session you set it up in, carrying that whole conversation with it every time, and if it's been more than an hour since the last turn, it's a cache miss on top. Start a fresh session in another terminal and run the loop from there.你没在打字时发生的轮次也得盯着。/loop 会在你设置它的那个会话里当成完整一轮来跑，每次都拖着整段对话，而且如果离上一轮已经超过一小时，还要再吃一次缓存未命中。另开一个终端，新开会话，在那边跑 loop。

SubagentsSubagent

The other way to keep something out of your context is to have it happen in a different one, which is what subagents are for. A subagent gets its own context window, with its own system prompt, the tools, and your CLAUDE.md, but not your conversation. It runs its own turns, and the only thing that comes back to the main session is its answer. Everything else is thrown away once it's done.还有一种不让东西进你上下文的办法：让它发生在另一个上下文里，这就是 subagent 的用处。Subagent 有自己的上下文窗口，自带系统提示、工具和你的 CLAUDE.md，但没有你这段对话。它跑自己的轮次，回到主会话的只有它的答案。其余的，做完就扔。

The downside of not having your conversation is that a subagent sometimes has to re-read things the main session already had, and it's paying for its own turns while it does. For a small job it's just overhead.没有你这段对话的坏处是，subagent 有时得把主会话里已经有的东西再读一遍，而且它自己的轮次也要付钱。小活儿的话，这就是额外开销。

It pays off when a job produces a lot of output you don't need to keep, like going through a log. Claude will often reach for one on its own for that kind of thing, and you can ask for one directly when it doesn't ("go through this log in a subagent"). Just keep in mind that the main session only gets back what the subagent chose to report.划算的时候，是一份活会产出大量你不需要留着的输出，比如翻日志。这类事 Claude 常常会自己去拉一个 subagent，它没拉的时候你也可以直接说（「go through this log in a subagent」）。只要记住，主会话拿回来的，只有 subagent 选择汇报的那些。

Tip

if there's a noisy job you hand off over and over, give it a subagent definition of its own with model: haiku (or sonnet). Otherwise it runs on whatever your main session is running on.

要是有份吵的活你反复往外丢，给它单独写一份 subagent 定义，加上 model: haiku（或者 sonnet）。否则它跑的是你主会话正在用的那个模型。

Where to look first先看哪里

Of everything above, four things are worth keeping an eye on, roughly in order of how much they cost:上面这些里面，有四件值得盯着，大致按它们有多贵排：