DEV Community: Nicola Alessi

I tracked every token my AI coding agent consumed for a week. 70% was waste.

Nicola Alessi — Sat, 28 Mar 2026 17:04:11 +0000

Last week Anthropic announced tighter usage limits for Claude during peak hours. My timeline exploded with developers asking why they're hitting limits after 2-3 prompts.

I'm the developer behind vexp, a local context engine for AI coding agents. Before building it, I did something nobody seems to do: I actually measured what's happening under the hood.

The experiment

I tracked token consumption on FastAPI v0.115.0 — the real open-source framework, ~800 Python files. Not a toy project.

7 tasks (bug fixes, features, refactors, code understanding). 3 runs per task. 42 total executions. Claude Sonnet 4.6. Full isolation between runs.

What I found

Every single prompt, Claude Code did this:

Glob pattern * — found all files
Glob pattern **/*.{py,js,ts,...} — found code files
Read file 1
Read file 2
Read file 3
...repeat 20+ times
Finally start thinking about my actual question

Average per prompt:

23 tool calls (Read/Grep/Glob)
~180,000 tokens consumed
~50,000 tokens actually relevant to the question
70% waste rate

That 70% is why you're hitting usage limits. You're not asking too many questions. Your agent is reading too many files.

Why this happens

AI coding agents don't have a map of your codebase. They don't know which files are relevant to your question before they start reading. So they do what any new developer would do on their first day: read everything.

The difference is that a new developer reads the codebase once. Your AI agent reads it on every single prompt.

And it gets worse. As your session continues, context accumulates. By turn 15, each prompt is re-processing your full conversation history plus the codebase reads. The cost per prompt grows exponentially, not linearly.

What actually helps

Free fixes (do these today):

Scope your prompts. "Fix the auth error in src/auth/login.ts" triggers 3-5 file reads. "Fix the auth error" triggers 20+.
Short sessions. Start a new session for each task. Don't do 15 things in one conversation.
Use /compact before context bloats. Don't wait for auto-compaction at 167K tokens.
Audit your MCPs. Every loaded MCP server adds token overhead on every prompt, even when you don't use it.
Use /model opusplan. Planning with Opus, implementation with Sonnet.

These get you 20-30% savings. The structural fix gets you 58-74%.

What I built

The idea: instead of letting the agent explore your codebase file-by-file, pre-index the project and serve only the relevant code per query.

I built this as an MCP server called vexp. Rust binary, tree-sitter AST parsing, dependency graph, SQLite. Runs 100% locally. Your code never leaves your machine.

Here's what changed on the FastAPI benchmark:

Metric	Before	After	Change
Tool calls/task	23	2.3	-90%
Cost/task	$0.78	$0.33	-58%
Output tokens	504	189	-63%
Task duration	170s	132s	-22%

Total across 42 runs: $16.29 without vexp, $6.89 with.

The output token drop surprised me. Claude doesn't just read less — it generates less irrelevant output too. Focused input context leads to focused responses. I didn't design for that, but it makes sense: less noise in, less noise out.

The output quality didn't drop. It improved.

I also ran this on SWE-bench Verified — 100 real GitHub bugs, Claude Opus 4.5, same $3 budget per task:

73% pass rate (highest in the lineup)
$0.67/task vs $1.98 average
8 bugs only vexp solved

Same model. Same budget. The only variable was context quality.

What this means for the usage limits debate

Everyone's arguing about whether Anthropic should raise limits or lower prices. Both miss the point.

The real issue is architectural: AI coding agents don't know your codebase. They compensate by reading everything. You pay for that compensation with tokens — and now, with tighter session limits.

Cheaper tokens help. Higher limits help. But reducing what goes into the context window in the first place is the only fix that works regardless of what Anthropic does with pricing or limits.

Full benchmark data (open source, reproducible): https://vexp.dev/benchmark

FastAPI methodology: https://www.reddit.com/r/ClaudeCode/comments/1rjra2w/i_built_a_context_engine_that_works_with_claude/

Free tier available, no account needed. I'm curious what numbers you see on your own projects — especially on repos larger than FastAPI.

How I Cut My AI Coding Agent's Token Usage by 65% (Without Changing Models)

Nicola Alessi — Thu, 26 Feb 2026 21:25:42 +0000

I've been using Claude Code on a 200-file TypeScript project. The model is great. The token bill was not.

The problem wasn't the model — it was what I was feeding it. Every session, the agent would read 30-40 files trying to orient itself before doing any actual work. Same files, same discoveries, same wasted tokens. Every single time.

After a lot of trial and error, I got my average input tokens per query from about 8,200 down to 2,100. Here's what worked, in order of impact.

Step 1: Write a real CLAUDE.md (not a vague one)

Most people write something like:

This is a TypeScript project using Express and React.
Please follow best practices.

This tells the agent almost nothing. It's going to read your whole codebase anyway.

What actually works is being specific about decisions, not descriptions:

## Auth
- Auth uses middleware in src/auth/middleware.ts
- JWT tokens, not sessions. Refresh token rotation in src/auth/refresh.ts
- DO NOT touch src/auth/legacy.ts — deprecated, will be removed Q2

## Database
- Prisma ORM, schema in prisma/schema.prisma
- All migrations must be backward-compatible
- Connection pooling handled by src/db/pool.ts, do not create new connections

## Conventions
- All API handlers in src/handlers/, one file per resource
- Error handling through src/lib/errors.ts, do not use try/catch in handlers
- Tests mirror src/ structure in tests/

The key: tell the agent what it would otherwise spend 10 minutes figuring out. Decisions, not descriptions. "We use Express" is useless. "Auth uses JWT with refresh rotation in this specific file" saves the agent from reading your entire auth directory.

Impact: about 20% token reduction. Significant, but not enough.

Step 2: Stop letting the agent grep your whole project

Here's what happens when you ask "how does authentication work in this project" without any context management:

Agent searches for "auth" across the codebase
Gets 40+ hits across middleware, tests, configs, legacy code, node_modules if you're unlucky
Reads 15-20 files to piece together the picture
Burns 8,000+ tokens before writing a single line of code

The agent doesn't need 40 files. It needs the auth middleware, the two things it depends on, and the three things that depend on it. That's maybe 5 files.

The question is: how do you give the agent the right 5 files instead of all 40?

This is where I stopped being able to solve it with prompting alone.

Step 3: Give the agent a dependency graph

I built a tool called vexp that pre-computes a dependency graph of your codebase at the AST level. Not grep, not text search — actual parsed relationships: who imports what, who calls what, what types flow where.

When the agent asks about authentication, instead of grep-matching "auth" across 40 files, it gets the relevant subgraph: the auth function, its dependencies, and its dependents, packed into a token budget you control.

Before (grep approach):

Agent reads: 40 files, 8,247 tokens
Relevant files: 5
Wasted: about 80% of input tokens

After (dependency graph):

Agent reads: capsule with 5 relevant nodes, 2,140 tokens
Relevant files: 5
Wasted: near zero

Same information, 74% fewer tokens.

Step 4: Solve the "amnesia" problem

Token reduction is half the problem. The other half: every new session starts from zero.

Monday the agent spends 20 minutes discovering that your payment module has a non-obvious dependency on a legacy Redis cache. Tuesday, new session, same 20 minutes. Wednesday, same again.

I tried every approach to make agents save their own notes:

"After completing a task, save your observations" — ignored 90% of the time
Detailed save instructions in CLAUDE.md — maybe 15% compliance
Making it a "required step" — agent writes "completed successfully, no issues" and moves on

The models are optimized for current-task completion. A tool that only benefits future sessions has zero value to the current context window. The incentive structure works against you.

What actually worked: passive observation. Instead of asking the agent to save things, watch what it does. Track which files it reads, what changes it makes at the AST level, and infer observations from its behavior. The agent that spent 20 minutes on your Redis dependency didn't save a note about it — but the tool call pattern and code changes tell you exactly what it learned.

These observations get linked to the code graph. When the underlying code changes, linked observations automatically go stale. So you're never feeding the agent outdated context.

Session 1: Agent discovers Redis dependency — observation saved passively
Session 2: Agent gets the observation immediately — skips the 20-minute rediscovery
Session 3: Someone refactors the Redis cache out — observation flagged stale — agent re-explores

The combined result

Metric	Before	After
Avg input tokens/query	8,200	2,100
Session start orientation	5-10 min	under 30 sec
Repeated discoveries	Every session	Once
Token reduction	—	65-74%

On a practical level this means:

If you're on Claude Max/Pro: 2-3x more work before hitting usage caps
If you're on API: direct cost savings on input tokens
On any plan: the agent starts working immediately instead of spending the first 10 minutes reading

Setup

vexp works as a VS Code extension or standalone CLI. It's an MCP server, so it works with any agent that speaks MCP: Claude Code, Cursor, Windsurf, Cline, Roo Code, Copilot, aider, Codex.

# VS Code
Search "vexp" in the extension marketplace

# CLI (for Claude Code, terminal agents)
npm install -g vexp-cli

Free tier: 2,000 nodes, full memory tools, no account needed. Runs 100% local — single Rust binary, SQLite, zero network calls.

Pro ($19/mo): multi-repo support, 50k nodes, priority updates.

What I'd do if I were starting today

Write a specific CLAUDE.md — decisions, not descriptions. 30 minutes, 20% improvement.
Set up a dependency graph — stop letting the agent grep. This is where the real token savings are.
Let memory accumulate — don't try to make the agent save notes. Observe passively and let the context build itself over 3-4 sessions.

The first step is free and takes 30 minutes. The rest takes about 5 minutes to install.

I'm the developer behind vexp. Happy to answer questions about the architecture, MCP integration, or anything else in the comments.

Show me your AI side project

Nicola Alessi — Tue, 15 Apr 2025 18:47:35 +0000

AI is exploding right now, and I’m sure many of you are tinkering with cool side projects—whether it’s LLM experiments, automation tools, or something completely unexpected.

Let’s share what we’re building! Drop a comment with:

Name/Description of your project

Tech stack you’re using

Biggest challenge you faced (or are still facing)

Demo link (if public)

I’ll go first:

Lumigo

What it is: A mood-based movie discovery tool that helps you find films and shows by describing how you feel or what kind of emotional vibe you’re looking for (instead of relying on generic genre tags).
Tech stack: Next.js, Python, Neon database
Challenge: Building a system that accurately interprets user mood descriptions and maps them to the right titles without making the experience feel generic or repetitive.
Try it: https://lumigo.tv
(still evolving — feedback is always useful!)