Skip to content
BSWEN
Blog

How Claude Code Manages Context and Saves You Money

Cowrie
Cowrie
Dev @ Bswen

I burned through $600 in one month pasting code into AI chats. Here’s why, and how I fixed it.

The Problem: I Was Using AI Wrong

Every time I had a coding problem, I did the same thing:

  1. Copy my entire file (3000 lines)
  2. Paste it into a chat
  3. Describe my problem
  4. Get back a 3000-line “fixed” version
  5. Hit an error
  6. Paste the error AND the file again
  7. Repeat…

This is the “paste everything” approach. It works, but it’s expensive and slow.

Why it’s expensive:

Each message sends the same code over and over. A typical bug fix session looks like this:

Token usage breakdown
Message 1: Paste 3000 lines + question = ~9000 tokens
Message 2: AI responds with 3100 lines = ~9300 tokens
Message 3: Paste error + 3000 lines again = ~9500 tokens
Message 4: AI responds with fix = ~3000 tokens


Total: ~30,000 tokens for ONE bug fix
Cost: ~$0.09 per session
Sessions per month: ~30
Monthly cost: ~$2.70 just on one type of task


Now multiply that across all your AI usage...

The real problem? I kept re-sending context that was already known.

The Solution: Let AI Read Files Directly

Claude Code works differently. Instead of me pasting files, it reads them from my filesystem.

Here’s the same bug fix with Claude Code:

Claude Code workflow
Me: "Fix the login bug in auth.js"
Claude Code: [Reads auth.js - finds relevant section]
Claude Code: [Makes targeted edit at line 234]
Claude Code: [Runs test]
Claude Code: [Fixes failing assertion]
Done.


Total tokens: ~500
Cost: ~$0.002

The difference is 40x.

How It Actually Works

Claude Code uses four techniques to cut token usage:

1. On-Demand File Reading

When I ask for help, Claude Code doesn’t need me to paste anything. It searches my project and reads only what’s relevant.

Manual vs Agentic approach
MANUAL (what I used to do):
┌─────────────────────────────────────────┐
│ User pastes:                            │
│ - auth.js (2000 lines)                  │
│ - user.js (1500 lines)                  │
│ - database.js (1000 lines)             │
│ Total: 4500 lines per message           │
└─────────────────────────────────────────┘


AGENTIC (Claude Code):
┌─────────────────────────────────────────┐
│ User: "Fix login bug"                   │
│ Claude Code:                            │
│ - Searches for "login"                  │
│ - Reads auth.js (300 relevant lines)    │
│ - Reads database.js (150 relevant lines)│
│ Total: 450 lines once                   │
└─────────────────────────────────────────┘

2. Edit, Don’t Regenerate

In a chat interface, when AI fixes code, it often returns the ENTIRE file. Claude Code uses targeted edits.

Full file vs Targeted edit
CHAT INTERFACE:
Here's your updated file:
[Lines 1-50 unchanged]
[Lines 51-100 unchanged]
[Lines 101-150: the actual fix]
[Lines 151-500 unchanged]
Tokens used: Entire file


CLAUDE CODE:
Edit file.js at line 120:
- old: function login(user) {
+ new: async function login(user) {
Tokens used: ~20

The edit approach uses 95% fewer tokens.

3. Built-In Execution Loop

The biggest hidden cost in my old workflow was the back-and-forth for errors.

Manual error handling
1. AI generates code
2. I run the code
3. I see an error
4. I copy the error
5. I paste error + context into chat
6. AI suggests fix
7. Repeat from step 2...

Claude Code handles this internally:

Agentic error handling
1. Claude generates code
2. Claude runs code (in terminal)
3. Claude sees error
4. Claude fixes it
5. Claude verifies fix
6. Done - no human intervention

This eliminates multiple round trips through the context window.

4. Automatic Context Pruning

Long conversations accumulate context. Old messages stay in the window even when they’re irrelevant.

Claude Code automatically:

  • Summarizes old discussion threads
  • Keeps active file references
  • Drops irrelevant history
  • Maintains project structure awareness

I don’t manage this manually. It just happens.

Common Mistakes I Made

Mistake 1: Over-Explaining

Unnecessary context
ME: "The login function is in src/auth/login.ts
     at line 234. It calls validateUser which is
     in src/utils/validation.ts. The database
     schema is in prisma/schema.prisma..."


BETTER: "Fix the login function"
Claude Code finds all this itself.

Mistake 2: Not Trusting the Agent

Hand-holding vs autonomy
ME: "Let me paste the error... wait, let me
     try something first... okay now try this..."


BETTER: Let Claude Code run, see errors, and fix
        them without interrupting.

Mistake 3: Repeating Context

Re-explaining vs documentation
ME: "Like I mentioned before, our architecture
     uses a service layer..."


BETTER: Create ARCHITECTURE.md once.
        Claude Code references it automatically.

Real Cost Comparison

I tracked my usage for a month, comparing my old workflow to Claude Code:

Monthly token usage comparison
                        OLD WAY      CLAUDE CODE
Bug fixes              ~300K tokens  ~8K tokens
Feature additions      ~450K tokens  ~15K tokens
Refactoring sessions   ~200K tokens  ~10K tokens
Code reviews           ~150K tokens  ~5K tokens


TOTAL                  ~1.1M tokens  ~38K tokens
Monthly cost           ~$33          ~$1.14

The savings come from not re-sending the same context repeatedly.

When This Matters Most

This approach helps most when:

  • Working with large codebases: No need to manually select files
  • Iterating on bugs: The execution loop runs without you
  • Long coding sessions: Context stays focused automatically
  • Cost-sensitive projects: 90%+ token reduction

Quick Start

  1. Install Claude Code CLI
  2. Stop pasting files into chats
  3. Just describe what you want
  4. Let it read, edit, and verify

The paradigm shift is simple: don’t bring context to the AI. Let the AI come to your context.

Key Takeaways

  • Claude Code reads files directly from your filesystem
  • Edit operations use 90%+ fewer tokens than regeneration
  • Built-in execution creates self-contained fix loops
  • Context pruning keeps conversations focused automatically
  • Create documentation files (ARCHITECTURE.md, etc.) for persistent knowledge

The future of AI coding isn’t bigger context windows. It’s smarter context management.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: