How to Cut Your Claude Code Token Costs Without Slowing Down

Claude Code charges by the token, and the bill sneaks up on you. Not because of the code it writes, that part is cheap. The money goes to everything the model re-reads on every single turn: a context window packed with old messages, a 40-file diff nobody asked for, a PDF quietly turned into images, the same CLAUDE.md shipped a hundred times a day.

Here is where the tokens actually go, and how to spend fewer of them without writing worse code or waiting longer.

First, look at the meter

You cannot cut what you cannot see. Before changing anything, find out what a session actually costs.

Every message you send re-sends the whole conversation so far. Turn 30 is not one prompt, it is thirty prompts stacked on top of each other, plus every file the agent read along the way. That is why a long session gets expensive near the end even when your last question was one line.

In AgentsRoom you can watch this live with the Claude Code token usage view: the running token count and cost of the current session, right in the interface, so you stop guessing. Zoom out to the project statistics dashboard and you see cost per project, per agent and per day. Once you can see the number climb, the fixes below stop being abstract.

Keep the context window tight

The single biggest lever is context size. A bloated window is a tax you pay on every turn for the rest of the session.

Start a fresh session when you switch tasks. Do not debug a webpack config in the same thread where you just refactored auth. Run /clear and start clean. The old messages were not helping the new task, they were just riding along on the invoice.

Watch out for the slow drift too. Long sessions do not just get pricey, they get dumber: the model starts losing the plot, repeating itself, forgetting what it decided twenty messages ago. AgentsRoom has a context drift detector that warns you when an agent is degrading, which is usually the exact moment to compact or restart. We wrote up the trick behind it in the canary method for catching agent degradation. Shorter sessions are cheaper and sharper at the same time.

Stop feeding it raw PDFs

This one is almost free money. When you drop a PDF into Claude, every page is also turned into an image, and vision tokens cost far more than text. A 20-page spec can burn tens of thousands of tokens before your question is even read.

Convert the file to Markdown first. One command with a free tool cuts the cost by up to 80% and the model answers just as well, often better, because it reads clean structure instead of squinting at page pictures. Full walkthrough here: convert PDF to Markdown to save tokens. Convert once, commit the .md to the repo, and every future turn reads cheap text.

Use the cheapest model that can do the job

Opus for everything is how bills explode. Renaming a variable, writing a commit message, or fixing a typo does not need your most expensive model. A smaller model does it for a fraction of the price and you will not feel the difference.

The habit is simple: match the model to the task. Heavy architecture work gets the big model, mechanical edits get the small one. AgentsRoom's Adaptive Mode makes this automatic by suggesting the cheapest capable model for what you are actually doing, so you stop paying premium rates for busywork.

Delegate the grunt work to a cheaper agent

Some tasks are big but shallow: writing tests for a module, checking a hundred files for a pattern, generating boilerplate. You do not want your expensive agent grinding through all of that inside one giant context.

Let it hand the job off instead. With agent delegation, a dev agent can pass a subtask to a second agent running a cheaper model, which does the repetitive work in its own clean context and reports back. The expensive agent stays focused and small, the cheap agent eats the volume. Your bill follows the split.

Stop re-explaining yourself

If you type the same three-paragraph prompt every time you start a code review, you are paying to send it every time. Save it once.

Keep your recurring instructions in a prompt library and your repeatable procedures as skills the agent loads only when it needs them. You reuse the wording instead of retyping and re-sending it, and a skill keeps its detailed steps out of the base context until the moment they are actually required. Same result, fewer tokens moved around.

Watch the cost of running agents in parallel

Parallel agents are a superpower, and they multiply your token spend by exactly the number of agents you run. Five agents reading the same shared context is five times the reads.

That is fine as long as you can see it. Keep the project statistics open when you scale up, point your agents at lightweight .md references instead of raw documents, and kill the ones that are done instead of leaving them idling in an expensive window. Parallelism should buy you speed, not a surprise invoice. If you are running coding agents in parallel, a shared, converted context keeps the whole fleet affordable.

The short version

Most of your Claude Code bill is not the code, it is the re-reading. So:

• Watch the live token counter so the number is never a surprise.
• Run /clear between tasks and keep sessions short.
• Convert PDFs to Markdown before you ask.
• Use the smallest model that can do the job, or let Adaptive Mode pick it for you.
• Delegate shallow, high-volume work to a cheaper agent.
• Reuse prompts and skills instead of re-typing them.

None of this slows you down. Shorter context and the right model usually make the agent faster and sharper, and the cheaper bill is the bonus.

Want the meter, the model routing and the delegation in one place? Download AgentsRoom and watch your token cost drop in the token usage view.