Practical Ways to Spend Fewer Tokens in Claude Code

Teams adopting an AI coding assistant tend to notice the bill in month two, look for a setting to fix it, and find there is not one. The spend is a product of habits, not configuration.

The habits below are the ones that made the biggest difference for us. None of them make the assistant less useful, which was the constraint we set ourselves.

First, understand where the tokens go

The thing that surprises people: every turn re-sends the conversation. The model is stateless, so the whole thread goes back with each message.

That means a long session is not linear. Message forty carries the cost of everything before it, and a file read early on is paid for again on every subsequent turn. Most overspend traces back to that single fact.

Start a fresh session per task

The single highest-value habit. When you finish a task and move to an unrelated one, clear the context rather than continuing in the same thread.

Carrying a debugging session about your build pipeline into a conversation about a React component means paying for that pipeline discussion on every turn, forever, for no benefit. Clearing is not losing progress. The code is on disk.

Write the project file once

Put the things you would otherwise explain every session into a CLAUDE.md at the repo root: the stack, the conventions, how to run tests, the directories that matter, and the things that are deliberately unusual.

This is the rare case where spending tokens saves tokens. That file is read once per session instead of you re-explaining the same context, badly, in a slightly different way each time.

Point at the problem

Vague instructions are expensive, because the assistant has to go and find out what you meant. “The tests are failing” triggers exploration. “The date parsing test in OrderServiceTests.cs fails on the timezone case” does not.

The same applies to files. Naming the file or the function scopes the work. Leaving it open means reading around until the right place turns up.

Reach for search before reading. Grepping for a symbol costs a fraction of reading five files hoping one contains it, and it is usually the better engineering instinct anyway.

Do not paste what you can point to

Large logs, whole files and full stack traces pasted into the chat get re-sent on every following turn. Save the output to a file and point at it. The assistant can read the part it needs and skip the rest.

Plan before large changes

For anything touching several files, agree the approach before code gets written. A plan is cheap. Rewriting a change that went the wrong way costs the original work, the correction, and the whole conversation in between.

This is the same argument as short iterations in any other engineering context: find out early, when changing direction is free.

Use subagents deliberately

Subagents are genuinely useful for isolated, well-scoped work, particularly searching a large codebase without dragging every file into your main context.

They are not free. A subagent starts cold and has to rediscover context you already have, so spawning one for something you could answer directly costs more than doing it yourself. Use them when the isolation is the point.

Match the model to the job

Not every task needs the strongest model. Renaming symbols, writing a commit message, tidying formatting or mechanical refactoring runs perfectly well on a smaller one. Save the expensive model for design decisions and hard debugging, which is where the difference actually shows.

Keep the early context stable

Repeated prefixes get cached, so a session that keeps its early context intact is cheaper than one that churns it. Practically: settle your project file and initial framing, then leave them alone. Editing the beginning of a long conversation is more expensive than it looks.

The habits, in short

Habit	Why it pays
Fresh session per task	Stops paying for unrelated history every turn
A good CLAUDE.md	Explain the project once, not every session
Name files and symbols	Removes exploration from the loop
Point at logs, do not paste them	Large pastes are re-sent forever
Plan the big changes	Rework costs more than agreement
Right-size the model	Most tasks do not need the biggest one

Adopt the first two and most teams see the difference immediately. The rest is refinement.

The wider point is the one we make about any AI system: the cost is rarely the model itself. It is everything you send it, over and over, without noticing.

---

We build AI into .NET systems and use these tools daily on client work. See our AI agents and copilots service, or get in touch.