Claude Code Cost Optimization: How to Reduce Token Usage

Claude code cost optimization is not about using the tool less. Most high token bills come from four fixable habits: loading entire codebases into context, re-explaining project setup every session, running broad exploratory prompts, and letting long sessions accumulate redundant history.

The fix is prompt discipline, not restraint. This guide covers the specific strategies that cut token usage by 40–60% without reducing the quality of what Claude Code produces.

Key Takeaways

• CLAUDE.md is the best cost lever: Storing project context once in CLAUDE.md eliminates 500–2,000 tokens of repeated setup per session, every session.
• Targeted file inclusion cuts waste: Including only files relevant to the task uses 60–80% fewer tokens than loading entire directories, with equal output quality.
• /compact prevents session bloat: Running /compact at natural breakpoints compresses conversation history from 10,000–20,000 tokens down to 1,000–3,000.
• Batch related tasks together: Grouping related tasks in one session reuses loaded context instead of paying the per-session overhead repeatedly.
• --verbose shows where money goes: Most developers who are surprised by their token usage have never run --verbose to see which prompts are consuming the most.
• Specific prompts cost less: "Refactor the auth middleware to remove the global state dependency" uses fewer tokens and produces better output than "improve this codebase."

AI App Development

Your Business. Powered by AI

We build AI-driven apps that don’t just solve problems—they transform how people experience your product.

Let's talk

Why Token Usage Spirals and Where Most Waste Comes From

Token waste in Claude Code almost always comes from four sources: broad context loading, repeated setup explanations, exploratory prompts, and long sessions without compaction. Understanding each one lets you address it directly.

Most developers who are surprised by their Claude Code bill have never examined which prompts are driving the cost. The patterns are consistent.

• Context loading waste: Including entire directories when editing one function means paying for 49 files of tokens that contribute nothing to the output.
• Repeated setup cost: Re-explaining your tech stack, coding conventions, and constraints at the start of every session costs 500–2,000 tokens each time.
• Exploratory prompt cost: Broad prompts like "what could be improved in this codebase?" require large context loads to answer a question that produces no direct implementation output.
• Long-session drift: In sessions running over an hour without /compact, Claude Code carries the full conversation history forward, including decisions from the first 20 minutes that no longer affect the current task.

At scale, these patterns compound significantly. Enterprise token management becomes a deliberate practice rather than an afterthought when teams run Claude Code across multiple concurrent projects.

How to Use CLAUDE.md to Compress Recurring Context

A well-written CLAUDE.md file of 300–500 words eliminates the need to re-explain your project in every session, saving 500–2,000 tokens per session from the first day you create it.

This is the single highest-return action available for reducing Claude Code costs. Write it once, maintain it as the project evolves, and it pays back every session.

• What to include: Tech stack and versions, architecture summary with key directory descriptions, coding conventions, known constraints, and any context you find yourself repeating in prompts.
• What to exclude: Large file contents, data samples, and anything that changes frequently. CLAUDE.md is for stable context, not volatile data.
• Daily savings estimate: At 5–10 sessions per day, a good CLAUDE.md saves 2,500–20,000 tokens daily per developer, before any other optimisation is applied.
• Maintenance signal: Every time you find yourself explaining the same thing in a prompt, that explanation belongs in CLAUDE.md, not in ad-hoc session context.
• Update triggers: Revisit CLAUDE.md when you add a new framework, change the architecture, or notice prompt explanations drifting from the file's current content.

For the full range of context management strategies that work alongside CLAUDE.md on large projects, that guide covers windowing, chunking, and session structuring in detail.

How to Use Targeted File Inclusion to Reduce Token Usage

Include only the file being changed, the files it directly imports, and any type definitions in use. Every other file in context costs tokens for zero additional output quality.

The default instinct is to include more context to improve output. In practice, precision almost always beats volume.

• The minimum context rule: Before writing a prompt, ask what Claude Code needs to read to answer it, not what might be relevant. This distinction cuts context by 50–80% on most tasks.
• Use @file syntax precisely: Include specific files rather than directories. Avoid test files when implementing features, and avoid feature files when writing tests.
• Separate interface inclusion: Include type definition files when they define interfaces in use, but not entire modules they belong to.
• The monorepo trap: The monorepo token overhead problem is significant. Always specify which package Claude Code is working in and include only that package's files, not the workspace root.
• When wide context is justified: Architectural questions, dependency analysis, and cross-cutting refactoring genuinely need broader context. Accept the token cost for analysis, then narrow back to targeted prompts for implementation.

The same precision applies when working on large existing codebases. The principle is always to include the minimum context that answers the question.

How to Write Prompts That Cost Less

A prompt naming the exact file, function, and required change uses fewer tokens and produces better output than a prompt describing a general problem. Specificity is both cheaper and more useful.

Prompt quality is the most controllable variable in per-task token cost. The difference between a scoped prompt and a vague one is often 2–5x the token count.

• The specificity rule: "Add input validation to the createUser function in /src/api/users.js to reject emails without an @ symbol" outperforms "improve the user creation endpoint" on every metric.
• Avoid exploratory prompts during implementation: "What problems does this code have?" is high-cost and low-certainty. Use exploratory prompts intentionally in dedicated analysis sessions, not as a default starting point.
• Batch related tasks in one session: Three changes to the same module in one prompt loads context once. Three separate sessions load it three times, adding 20–40% to total token spend for those tasks.
• One question per prompt: Compound prompts ("fix the bug AND add tests AND update the README") force Claude Code to hold multiple task states simultaneously, producing longer outputs with more room for error.

Each prompt is a cost decision. Treat it like one.

How to Use the /compact Command Effectively

The /compact command compresses full conversation history into a structured summary, preserving key decisions and context while eliminating redundant token history. Most Claude Code users have never used it.

A two-hour session without /compact may carry 10,000–20,000 tokens of history by the end. That same session with two /compact checkpoints typically runs 3,000–6,000 tokens total in carried context.

• What /compact does: Compresses conversation history into a summary of key decisions, outputs, and active context, without carrying every exchange forward.
• When to use it: At natural breakpoints in long sessions: after completing one feature before starting the next, after a major refactoring pass, or after 30–45 minutes of continuous work.
• Token impact: A typical /compact reduces 10,000–20,000 tokens of session history to 1,000–3,000 tokens while preserving the actionable context for the next task.
• What /compact does not preserve: Exact wording of earlier exchanges and specific prompt structures. If these matter, explicitly ask Claude Code to include them in the compact summary before running the command.
• Build it into workflow: Treat /compact as a git commit checkpoint for a session. Run it when one unit of work is complete and you are moving to the next.

Developers who discover /compact typically report it as one of the highest-impact changes to their daily token spend.

How to Monitor Claude Code Costs with --verbose

The --verbose flag surfaces token counts per prompt, cumulative session totals, and cache hits. Running it for one working day almost always reveals 2–3 high-consumption patterns the developer did not know existed.

Optimisation without measurement is guesswork. --verbose converts your session into cost data you can act on.

• What --verbose surfaces: Input token count, output token count, and cache tokens per prompt, plus the running session total as you work.
• The cost calculation: At current rates, one million input tokens via direct API costs approximately $3 (Sonnet). Token counts from --verbose translate directly into per-task cost data. For the full breakdown of how token costs translate to plan costs, the Claude Code pricing tiers guide covers the Pro and Max thresholds and when each makes sense.
• Finding the 20% of prompts driving 80% of cost: Most developers find a small number of broad context loads or exploratory prompts account for the majority of daily token spend.
• Team-level monitoring: Across a team, --verbose output logs reveal whether usage variance between similar developers reflects task complexity or prompt discipline differences.

Run --verbose for one full working day before making any other optimisation decision. The data tells you exactly where to focus.

Conclusion

Claude Code costs are predictable and controllable. Measure them first, then optimise with specifics, not with vague intentions to "use it less."

CLAUDE.md, targeted file inclusion, /compact, and scoped prompts address the four largest sources of waste. None of them require reducing output. They require using the tool more precisely.

Enable --verbose on your next Claude Code session and run it for a full working day. The two or three prompts that consumed the most tokens will tell you exactly where to focus.

AI App Development

Your Business. Powered by AI

We build AI-driven apps that don’t just solve problems—they transform how people experience your product.

Let's talk

Want to Deploy Claude Code Across a Team Without Costs Spiralling?

Individual Claude Code usage is manageable. Team-level usage without cost controls is a different problem: every developer has different prompt habits, different context-loading patterns, and no shared framework for what "efficient use" looks like.

At LowCode Agency, we are a strategic product team, not a dev shop. We have structured Claude Code workflows for development teams at scale, including CLAUDE.md templates, prompt discipline guidelines, and per-project cost tracking frameworks.

• CLAUDE.md templates: We build project-specific context files that eliminate repeated setup tokens across every developer session from day one.
• Prompt discipline guidelines: We define team-level standards for prompt specificity, task batching, and context scope that reduce per-task token costs consistently.
• Token cost review: We conduct a Claude Code cost review that identifies the highest-waste patterns in your current usage before recommending any changes.
• Session workflow design: We structure /compact checkpoints, task batching strategies, and session length guidelines tailored to your team's workflow and codebase type.
• Monorepo and large codebase setup: We configure targeted file inclusion patterns and package-scoped prompting for complex repositories where context bloat is the primary cost driver.
• Plan and API access guidance: We help teams decide between Pro, Max, and direct API access based on actual --verbose data, not estimates.
• Ongoing optimisation: We monitor token costs as usage scales and adjust guidelines when new patterns emerge or the team's workflow changes.

We have built 350+ products for clients including Coca-Cola, American Express, and Medtronic. We know what prompt discipline at scale looks like and how to make it stick across a team.

If you want to scale Claude Code across your team without watching costs spiral, talk to our team about your current usage pattern and where the waste is.