Paste This Into Claude Code — The $20 Trick That Keeps Your Tokens Under Control

Pasting a single audit prompt into Claude Code is one of the fastest ways to find out exactly why your token limit is disappearing so fast — and then fix it without spending a cent more on your plan.

If you have ever opened Claude Code in the morning, given it a few tasks, and then watched it tell you to come back in five hours, you are not alone.

The frustrating part is you probably did not run it for eight hours straight.

You did not ask it to rebuild an entire codebase from scratch.

You just worked normally, and somehow the session limit hit you like a wall anyway.

That is exactly what happened to one developer who set out to trace every single token charge in his session logs — and what he found changed the way a growing number of Claude Code users now manage their daily workflow.

His user-typed input accounted for exactly 0.01% of his total token bill.

Everything else — 99.99% of his charges — came from the way Claude Code handles conversation history under the hood.

Once you see that mechanism clearly, you can cut most of your token spend without changing how you work.

👉 Start a 1-Person Business With Claude AI — Free Quick-Start Guide — grab this free resource to start applying AI tools like Claude Code to a real income system from day one.

This article walks you through a paste-ready audit prompt, then seven Claude Code token consumption control tips ranked from highest to lowest impact — starting with the one that is completely free and ending with the hidden trap that is quietly doubling the bill for thousands of users right now.

Why Claude Code Feels Expensive Even When You Are Careful

Before the fixes make sense, the mechanism has to make sense.

Claude Code has no memory between turns.

None at all.

Every single time you press enter, your entire conversation — every message you have sent and every response you have received — gets bundled up and sent to the model again from the very beginning.

Your first message costs exactly what you typed.

Your second message costs what you typed, plus the model’s answer, plus the first message all over again.

By the time you are at turn twenty, the tiny note you just wrote sits at the top of a massive pile that includes every word from every previous exchange — and you are paying to send all of it, again.

Picture a 3,000-token file your agent reads at turn four of a forty-turn session.

That file does not cost you 3,000 tokens.

It costs you 3,000 tokens multiplied by thirty-seven more times, because it gets resent on every remaining turn.

This is why the usage meter climbs so fast even during light work.

It compounds in the background and the interface gives you almost no visibility into it — until you know where to look.

👉 Get Access to: The AI Traffic Vault — the full system for building AI-powered traffic and income using tools like Claude, Medium, Flipboard, and more.

The Audit Prompt: Find Your Actual Problem First

The smartest starting point is not guessing which fix applies to you.

Every Claude Code setup is different.

The mix of tools you have connected, the size of your memory files, the way your sessions are structured — all of it adds up differently for every user.

The right move is to paste a single audit prompt into Claude Code and let it read your actual configuration.

A working audit prompt tells Claude Code to do four things at once: read your current context breakdown, check whether tool deferral is active, measure the size of your memory files, and flag any scheduled tasks that are firing while you sleep.

You can screenshot the prompt from any technical walkthrough of this topic, or you can write a version of it yourself using those four instructions as your guide.

Once your agent runs it, you get back a ranked list of what is consuming the most tokens in your specific setup.

That list tells you which of the seven fixes below matter most for you and in what order to apply them.

The fixes that move the needle for someone with fifteen connected tools are completely different from the fixes that help someone running heavy scheduled automation.

Start with the audit. Then work the list.

Fix 1: Use /clear Between Jobs — It Costs Nothing and Resets Everything

This is the highest-leverage thing you can do, and it is five letters long.

When you finish one job and move on to a different one, type /clear and press enter.

Do not keep working in the same thread just because it is convenient.

That old conversation is not sitting there quietly.

It is being resent on every message you send, inflating your token count with every turn, until the session ends.

Watch what happens when you run /clear mid-session.

A context window sitting at 80,000 tokens drops back to zero percent instantly.

Anthropic’s own documentation states it plainly: when you want a fresh start rather than continuity, /clear is the correct tool and it costs you nothing.

Here is why this fix beats everything else on this list.

Every other fix reduces one component of your context window.

Clearing resets the entire base that all of those components are a fraction of.

If 96% of your spend is the model re-reading conversation history — which is exactly the figure one developer traced in his own session logs — then the tool that deletes the history is the one that matters most.

One thing to do before you clear: run /rename inside your current session first so you can use /resume later if you urgently need to return to it.

You are not losing the work.

You are just stopping the next job from carrying the weight of the last one.

👉 Get Access to: Start a 1-Person Business With Claude AI — the complete package for launching a solo AI business with Claude as your core production tool.

Fix 2: Pick Your Model Once and Leave It Alone

This one is counterintuitive and it catches almost every Claude Code user at least once.

When your token limit gets low, the natural instinct is to switch to a cheaper model.

You open /model, drop from Claude Opus to Claude Sonnet, and feel like you made a smart move.

You did not.

That switch is actually one of the most expensive single actions you can take inside a live session.

Here is why.

Claude Code caches your conversation, and cache reads cost roughly one-tenth of the price of normal output tokens.

That is the main reason long sessions do not bankrupt you — most of the history is being read from cache rather than reprocessed from scratch.

But the model you are using is part of the cache key.

When you change the model mid-session, none of your conversation history matches the cache anymore.

The entire conversation gets reprocessed at full price in a single turn.

On Claude Opus, at 200,000 tokens of context, that turns a ten-cent turn into a one-dollar turn.

Ten times more expensive.

And it is completely invisible — no warning, no confirmation, no indicator that it just happened.

The same cache-busting effect applies to changing your effort level, switching to fast mode, connecting or disconnecting an MCP server, enabling a plugin that ships its own MCP server, and running the compaction command.

One particularly painful edge case: upgrading Claude Code itself and then resuming a long session triggers the same effect.

Anthropic’s documentation describes that specific action as the most expensive single request you can send.

Things that are safe mid-session include editing files in your repo, updating your memory file, changing output style, adjusting permission mode, and spawning sub-agents.

The rule is simple: choose your model and your effort level at the very start of a session, and then leave those settings completely alone.

If you want to work on a budget model, start there.

Do not migrate to it.

Fix 3: Filter Tool Output Before It Lands in Your Context

The next three fixes address token costs that you never directly created — they come from what Claude Code does automatically while completing your requests.

Consider this scenario.

You type: “Install Remotion for me.”

Your agent runs the command and 800 lines come back.

Package names, version numbers, deprecation warnings, funding notices, peer dependency alerts — all of it.

You read none of it.

You just needed confirmation that the installation worked.

But your agent does not get to skim.

All 800 lines went into your conversation, and you pay for them again on every subsequent turn until you clear.

The fix is a small output filter file that sits between your agent and the terminal command.

Your agent writes the file itself when you ask it to.

You give it a simple instruction: “Create a compact output filter that trims verbose terminal responses before they enter our context window.”

The agent builds it once and it applies automatically to every session after that.

Anthropic ships a reference version of this type of filter in their documentation, with their own note that it can reduce context from tens of thousands of tokens down to hundreds.

That is a reduction of roughly 99% on verbose command output — from a file your agent writes in under a minute.

Fix 4: Disconnect the Tools You Have Stopped Using

Every tool you connect to Claude Code comes with what amounts to an instruction manual.

That manual describes what the tool can do, what format to use when calling it, and what format to expect in return.

Your agent has to read the relevant parts of that manual before it is allowed to touch the tool.

The token cost of some popular integrations is significant.

The GitHub MCP server costs approximately 26,000 tokens per session.

The Slack MCP server costs approximately 21,000 tokens.

All of that loads into your context before you type a single word.

Anthropic has shipped an update that introduces what they call tool deferral — instead of reading every manual upfront, your agent now loads a contents page and only opens the specific section it needs, when it needs it.

That update alone cut tool-related token overhead by roughly 85% for most users.

To confirm you are on the new behavior, run /context inside Claude Code, find the tools line, and check that it says “deferred.”

But even with deferral active, you are still paying for the contents page of every tool you have ever connected — and that contents page grows every time you add something new.

The thirty-second fix: type /tools in Claude Code to open a panel showing every connected tool with a toggle next to each one.

Go through the list and turn off anything you have not actively used in the past month.

You are not deleting the integration — it stays set up — but it stops loading until you turn it back on.

And because turning tools off does not rebuild the cache the way switching models does, you can do this mid-session without any penalty.

👉 Get Access to: The AI Traffic Vault — learn how to build the kind of solo AI workflow where every tool you run is earning its place.

Fix 5: Use Sub-Agents Correctly — They Move Tokens, Not Delete Them

Sub-agents are one of the most talked-about Claude Code features and also one of the most misunderstood ones when it comes to token costs.

The common advice is that delegating work to sub-agents saves tokens.

That advice is half true.

Here is the full picture using Anthropic’s own published numbers.

A sub-agent that reads 6,000 tokens of files and returns a 420-token summary to your main context looks like a massive win.

In your main session window, it is.

But the sub-agent also loaded its own system prompt, its own copy of your memory file, and its own tool manifests before it did anything.

Total burn for that sub-agent: roughly 9,800 tokens.

Total saved in your main context: roughly 5,700 tokens.

In isolation, you spent more than you saved.

Anthropic’s own multi-agent research documentation is direct about this: agents use around four times more tokens than standard chat, and multi-agent systems use approximately fifteen times more tokens than chat.

So when is using a sub-agent worth it?

Three conditions need to be true at the same time.

The output the sub-agent produces is high volume.

You will not need the detailed version of that output again later in the session.

The main session still has many turns left to run.

That third condition is where the math flips.

Those 5,700 tokens you avoided in your main context would have been resent on every remaining turn.

If the session continues for thirty more turns, the saving compounds dramatically.

But if you delegate to a sub-agent and then immediately end the session, you paid extra for nothing.

One practical upgrade: set your sub-agents’ model to Claude Haiku.

Haiku is roughly five times cheaper for the isolated work the sub-agent does, and because it runs in a completely separate context, it does not touch your main session’s cache.

Fix 6: Use the Right Model Per Task — Without Switching Mid-Session

There is a widespread belief in the Claude Code community that you should always use the smartest available model for everything.

That belief is expensive.

A large portion of what most users ask Claude Code to do is genuinely simple work.

Rename these files.

Write a commit message.

Clean up this list.

Format this output.

The useful principle is to match model capability to task complexity — using a lighter model for work that does not require deep reasoning.

But as Fix 2 established, you cannot switch models mid-session without busting your cache.

The smarter approach is to assign models at the task level rather than the session level, using sub-agents and skills.

Set your sub-agents to run on Claude Haiku for grunt work.

Keep your main session on whatever model you need for the complex reasoning.

This way you get the cost benefits of model-matching without ever touching your main session’s cache key.

Fix 7: Audit Your Scheduled Tasks — They Run While You Sleep

This is the trap mentioned at the start.

A scheduled task fires on its set interval whether you are at the keyboard or not.

Every time it fires, it sends your full context — not a portion of it, the entire thing.

If that task is attached to a bloated session, you are paying for that full context on every single fire, around the clock.

Here is where it escalates from expensive to painful.

Anthropic’s cache window on a subscription plan lasts one hour.

If your scheduled task runs less frequently than once per hour — say, every ninety minutes or every two hours — each fire misses the cache entirely.

Instead of paying the one-tenth cache read rate, you pay full price for reprocessing the entire context every time.

That is ten times the cost, on a schedule, forever, while you sleep.

The counterintuitive fix: if your task can run every forty-five minutes instead of every ninety minutes, it is actually cheaper to run it more often, because it stays within the cache window.

A separate but related concern worth clearing up: leaving Claude Code open in the background without any active tasks.

Anthropic’s documentation puts background idle usage at under four cents per session.

That is not your problem.

Your scheduled tasks are your problem.

Run /context in Claude Code, find the scheduled tasks section, and review what is running, at what interval, and with how much context attached.

What Doesn’t Work — Common Advice That Wastes Your Time

Knowing what to ignore is just as valuable as knowing what to do.

Writing shorter prompts.

In a detailed session log analysis, everything the user typed — every question, every instruction, every follow-up — came to 0.01% of the total token bill.

Your prompt length is a rounding error.

Vague prompts do cost you, but the cost comes from the extra file reads and rework they trigger, not from the number of words in the prompt itself.

Using the Compact command to save tokens.

Compaction is backwards.

To generate a summary of your conversation, Claude Code has to send your entire conversation one more time — making the compaction message the single most expensive message of the session.

After compaction, the cache is wiped on purpose, because the summarized conversation no longer matches what was cached.

If you want continuity, use compaction.

If you want savings, use /clear.

If you want to undo recent turns without the full cost, use /rewind — it takes you back to a point the cache already knows, so nothing has to be reprocessed.

Taking screenshots of text to save tokens.

An image is not cheaper than the words it contains.

On Claude Opus, a single screenshot of a standard screen costs approximately 2,700 tokens.

A 4K screenshot costs close to 5,000 tokens.

Paste the text directly instead.

It is cheaper and your agent can actually work with it — it cannot edit a screenshot.

Sending PDFs instead of plain text.

Every page of a PDF costs between 1,500 and 3,000 tokens for the text content alone.

Claude Code also renders a visual representation of each page, so you effectively pay for each page twice.

Ask your agent to convert the PDF to a plain text file first and the same document costs roughly one quarter as much.

👉 Get Access to: The Flipboard Traffic Workflow Kit — another way to put Claude AI to work driving real traffic without burning through your limits.

The Four Built-In Tools That Show You Everything

Once you start managing Claude Code token consumption control tips actively, these four built-in commands become your daily dashboard.

/context — Shows you a line-by-line breakdown of exactly what is in your context window right now.

This is the one you will use most often.

It tells you exactly how much room each component is taking up so you can make targeted decisions rather than guessing.

/usage — Shows you how much of your plan you have burned through and what specifically burned it.

Not roughly — it names the specific skill, the specific tool, the specific agent that consumed the tokens.

If something on your machine is quietly eating your limit in the background, this is where it shows up.

/cost — Shows you what the current session has cost in total and breaks it down between your agent re-reading history versus doing new work.

That ratio alone tells you immediately whether you need to /clear and start fresh.

The burn rate meter — The live usage indicator in the corner of your Claude Code screen.

Having a moving number visible while you work changes your habits more than any written rule.

When you can see the meter climbing, you naturally start to question whether a task needs to be run in the current session or whether it should start a new one.

One more resource worth knowing: every session you have ever run is logged locally on your machine, and every reply in those logs includes what it cost.

You can point a sub-agent at that folder and ask it to calculate your own version of the 0.01% figure.

That is your number, from your actual usage, not an approximation from someone else’s setup.

How This Connects to Building a Real Solo AI Business

Managing Claude Code properly is not just a developer habit.

If you are using Claude Code as part of a solo content or digital product business — writing articles, building tools, automating workflows, creating training materials — your token efficiency directly affects your operating margins.

Every session that hits the limit early is a session where work stops.

Every unnecessary cache bust is a cost that does not show up on an invoice, it just shows up as a shorter runway on your monthly plan.

The seven fixes in this article are not about being cheap.

They are about running a clean, intentional operation where every tool earns its place and every session starts from the right baseline.

If you want to go deeper on building that kind of one-person AI business system, two resources will give you the full framework.

👉 Get Access to: The AI Blog Monetization Quickstart Guide — the step-by-step system for monetizing AI-assisted content starting with what you already have.

👉 Get Access to: The Medium Mastery — the deep-dive guide to building traffic and income on Medium using AI-powered content workflows.

The Summary: Seven Fixes, Ranked by Impact

Here is the complete list in order of what actually moves the needle.

Fix 1 — Use /clear between jobs. It is free. It resets the entire base that every other cost is a fraction of. Do this first and do it every time you shift to a new task.

Fix 2 — Pick your model and effort once. Choose at the start of the session and leave those settings completely alone. The switch you make to save money is the most expensive action on the board.

Fix 3 — Filter terminal output before it lands. Ask your agent to write a compact output filter once. From that point on it runs automatically and saves tens of thousands of tokens per session.

Fix 4 — Disconnect tools you are not using. Run /tools, turn off anything idle, and confirm the tools line in /context says “deferred.”

Fix 5 — Use sub-agents when the session still has many turns left. Not as a blanket saving strategy — as a targeted one. Set sub-agent models to Haiku for the isolated work.

Fix 6 — Assign models per task, not per session switch. Use sub-agents and skills to run lighter models on simpler work without ever touching your main session’s cache key.

Fix 7 — Audit your scheduled tasks. Find what is running, at what interval, and whether it is hitting the cache window. If it runs less than once an hour, it is paying full price every single time.

The labs are not going to solve this for you.

Anthropic’s incentives are not aligned with minimizing your token usage — that is not a criticism, it is just how the business works.

Your session is your desk.

You have to keep it clean.

Run the audit prompt once a week, or any time you feel like your limits are burning faster than the work justifies.

Things drift.

You add a server, install a plugin, change a setting, and six weeks later you are back where you started wondering why the limit hit at noon again.

The audit catches it before it compounds.

👉 Get Access to the full Package: Start a 1-Person Business With Claude AI — everything you need to launch and grow a solo AI business from scratch.

We strongly recommend that you check out our guide on how to take advantage of AI in today’s passive income economy.