Why one Claude Code session per project saves tokens

It does, but not for the reason most people guess. Moving a session to another project doesn’t make Claude re-read anything it wouldn’t have read anyway. What costs you is that Claude Code sends the whole conversation with every request, so a session carrying one project’s history pays for that history on every step of the other project’s work. The same mechanism explains why /clear between unrelated tasks helps, why the first message after a long break can be the most expensive one, and why a cropped screenshot is cheaper than a full screen.

The prices below are from Anthropic’s docs as of October 2026, worked for Claude Opus 5.5. On a Pro or Max plan, read the dollar figures as plan usage: it scales the same way.

How Claude Code spends tokens

Claude has no memory outside the conversation. Each time it does something, whether that’s answering you or a tool call such as reading a file or running a test, Claude Code sends a request carrying the conversation so far. Anthropic’s cost guide says it directly: “Claude Code sends your full conversation with every request, and each time Claude uses tools it sends another request carrying that batch of tool results.”

The prompt cache is what keeps that affordable. Anything Claude has already seen is read from the cache at a fraction of the normal input price:

Token type	Price vs. normal input	Opus 5.5, per million
Normal input	1×	$4.00
Cache read	0.05×	$0.20
5-minute cache write	1.25×	$5.00
1-hour cache write	2×	$8.00

The $4 input price is from Anthropic’s vision docs and the multipliers from the prompt caching docs. Sonnet 5.5 also reads from cache at 0.05×; most other models read at 0.1×.

Cheap isn’t free. Every step pays the cache-read rate on the whole conversation, so the bigger the conversation, the more each step costs. Two more things move the bill:

The cache expires. By default an entry lives for 5 minutes and is refreshed each time it’s used. Some Claude Code setups get a 1-hour lifetime instead. After a longer break, your next message reprocesses the whole conversation at the cache-write price.
Compaction is a big request. When the conversation nears its limit, Claude Code summarizes it. In Anthropic’s words, “/compact reads the conversation it summarizes, so compacting a large context is itself a large request,” while “/clear costs nothing.”

Does Claude re-read files when you switch tasks?

No. Claude reads a file when a task needs it, and what it read stays in the conversation. Give your UI session a fix in the shared core and it reads the core files that fix needs: the same files a separate core session would read. Switching doesn’t add any reading of its own.

Re-reading does happen in a few cases:

after /clear, because the conversation starts empty,
after compaction, when the summary no longer holds a file in full,
in a very long session, when Claude Code clears old tool results to save space,
when a file changed since Claude read it, for example because you edited it in another window.

So mixing projects doesn’t cost extra reading. It costs carrying.

What carrying another project’s history costs

Say your UI session has been going all morning and holds 150,000 tokens of conversation. You hand it a fix in the core, and the fix takes 40 steps: reads, edits, a test run, a couple of retries. Each of those 40 requests carries the 150,000 UI tokens, none of which have anything to do with the core.

Step	Arithmetic	Cost on Opus 5.5
One step	150,000 × $0.20 per million	$0.03
The 40-step fix	40 × $0.03	$1.20
First step after a break	150,000 × $5.00 (or $8.00) per million	$0.75 (or $1.20)

A separate core session pays none of that, because it only carries core history. $1.20 for one fix isn’t much on its own. It adds up over a day of switching, and the mixed session also reaches compaction sooner. Cost isn’t the only loss either: Anthropic’s best practices note that “long sessions with irrelevant context can reduce performance.”

The cost guide’s own diagnosis for unexpectedly high spend is that it “usually traces back to long sessions that were never cleared.”

My setup is three VS Code windows, one each for the app, the marketing site and the shared core, each with its own Claude Code session. There’s nothing clever about it. It just keeps each conversation about one thing.

When interrupting Claude costs tokens, and when it saves them

Waiting is free. An idle session uses almost nothing; Anthropic puts background activity at “typically under $0.04 per session.” Letting Claude finish before you hand it the next thing costs you nothing extra.

Interrupting costs tokens when you add unrelated work mid-task. That request becomes part of the conversation, and every request for the rest of the session carries it. It also costs when you pull Claude off a half-finished task: the tokens it spent getting there are gone, and picking the task up later can mean redoing part of it.

Interrupting saves tokens when Claude is going the wrong way, because every step in the wrong direction is billed. The cost guide’s advice: “If Claude starts heading the wrong direction, press Escape to stop immediately.” Then redirect it, or use /rewind to go back to an earlier checkpoint.

So: don’t interrupt to add new work, do interrupt to correct.

The first message after a break

If you step away for longer than the cache lifetime, your next message rebuilds the cache for the entire conversation at 1.25× or 2× the normal input price instead of 0.05×. That’s 25 to 40 times the per-token cost of a step taken a minute earlier. In the example above, it’s the $0.75 to $1.20 line.

If the next task is unrelated anyway, run /clear before you send it. You skip the rebuild and the carried history in one go.

To see what’s going on in a session, run /usage. Since Claude Code v2.1.251 its Session block has a “Prompt cache (main)” line showing how much of your input came from cache, how many misses there were, and whether the cache is warm or cold right now.

Screenshots: snip the part that matters

Images are tokens too, and they stay in the conversation like everything else. Claude counts an image in 28×28-pixel patches, ⌈width / 28⌉ × ⌈height / 28⌉ tokens, with a cap per model. Claude 4.7 and later, which includes Opus 5.5, take up to 2,576 px on the long edge and 4,784 tokens per image. Older models stop at 1,568 px and 1,568 tokens.

Screenshot	Arithmetic	Tokens on Opus 5.5
Full 4K screen	3840×2160, downscaled to 2576×1449	4,784
Full 1080p screen	1920×1080: 69 × 39	2,691
800×450 snip	29 × 17	493

The snip costs about a fifth of a full 1080p screen, and every later step in the session carries it. Treat these as the most an image of that size can cost: Claude Code may shrink large images before sending them.

Don’t crop so tight that Claude loses what it needs to understand the problem. The vision docs warn against “cropping out key visual context solely to enlarge the text.” A box around the broken component and the things next to it is usually right.

Habits that follow

One session per area. The app in one window, shared code in another. Each conversation carries only its own history.
/clear between unrelated tasks in the same window. Don’t clear when the next task touches the same files: there the history saves Claude from reading them again. Anthropic’s best practices make the same call: “Sometimes you should let context accumulate because you’re deep in one complex problem and the history is valuable.”
Let Claude finish before you hand it new work, and press Esc as soon as it goes wrong.
After a long break, clear before unrelated work instead of paying to rebuild a cache you don’t need.
Snip the region, not the screen.
Check /usage instead of guessing.

Where this doesn’t hold

Related tasks. Two fixes on the same page share files. Clearing between them throws away reads you’ll pay for again.
Every session has a startup cost. The system prompt, tool definitions, CLAUDE.md and skill descriptions load in each session. That part is cached, but three sessions pay for it three times.
Shared files get read twice. If your UI and core sessions both need the same types file, both read it.
These figures are worked, not measured. They’re arithmetic from Anthropic’s published prices, not a benchmark of real sessions. Your own /usage numbers are the ones to trust.

Where CueTray fits

CueTray, the app this site is for, doesn’t save tokens on its own. Picking up a cue (a saved screenshot and instruction) with /next-cue adds a small, fixed amount to each one: the command’s instructions, plus reading the cue and its screenshots.

What it does is keep the next request out of the conversation until you decide to send it. You snip the problem and write what should change while Claude finishes its current work, and the cue waits in that project’s .cuetray folder. Because it’s on disk, it survives /clear and closing VS Code, so clearing before an unrelated cue costs you nothing but the old conversation. And a snip is a region, not the whole screen.

See how CueTray works, or read the guide for what /next-cue does step by step.