How to Cut AI Coding Assistant Costs by 58%: A Benchmarked Approach

I stopped guessing about AI coding costs and ran a controlled experiment.

Claude Code was burning through my API budget, and I knew context bloat was the culprit: too many files, too many tokens, too much noise. Instead of hand-waving about it, I measured everything.

The result: dependency-graph context engineering cut costs by 58%, made tasks 22% faster, and reduced output tokens by 63% on a real FastAPI codebase.

This post walks through the benchmark setup, the numbers, and exactly how to replicate it with vexp’s context engine.

Benchmark Setup

To make the numbers meaningful, the experiment had to be disciplined and reproducible.

Codebase

• Real FastAPI application
• Production-grade: auth, database layer, background tasks, API routes
• Not a toy example or contrived demo

Tasks

Seven representative development tasks:

1. Add a new endpoint
2. Fix a bug in the auth module
3. Refactor a database query
4. Add input validation
5. Write a test
6. Debug an async issue
7. Update API documentation

These were chosen to mirror typical day-to-day work, not to cherry-pick scenarios where vexp looks good.

Arms

• Without vexp: Claude Code’s default context loading
• With vexp: vexp dependency-graph context engine via MCP

Runs

• 21 runs per arm (42 total)
• Enough samples to get stable averages and see real patterns

Model

• Claude Sonnet
• Chosen because it’s the most common model for coding via Claude Code

Metrics

For every run, I measured:

• Input tokens
• Output tokens
• Cost per task
• Time to completion
• Task quality (subjective but consistent rubric)

Results

Here are the core numbers from the benchmark:

| Metric | Without vexp | With vexp | Change |

|----------------|-------------|-----------|----------|

| Input tokens | Baseline | −65–70% | −65–70% |

| Output tokens | Baseline | −63% | −63% |

| Cost per task | Baseline | −58% | −58% |

| Time per task | Baseline | −22% | −22% |

The input token reduction is expected: vexp’s dependency-graph context engine is designed to send less irrelevant code.

The 63% drop in output tokens is the surprising part.

Why output tokens dropped 63%

The explanation is simple:

• When the model sees less noise, it produces less noise.
• Focused, structurally relevant context leads to focused, concise responses.
• Every token you save on input tends to save proportional tokens on output.

In practice, this means:

• Shorter, more targeted diffs
• Fewer tangents and speculative explanations
• Less regurgitation of irrelevant code

Quality didn’t suffer. If anything, it improved because the model wasn’t distracted by 300+ unrelated files.

Why AI Coding Costs Are So High

Most AI coding agents are optimized for caution, not efficiency.

When they’re unsure what’s relevant, they over-include:

• More files
• More context
• More tokens

On a small codebase (under ~1,000 lines), this doesn’t matter much. Everything fits into the context window, and the waste is negligible.

On a production codebase, it’s a different story.

In one refactor, I watched Claude load 312 files to modify a single authentication function. The function and its direct dependencies lived in about 7 files. The other 305 were pure noise.

Given Claude’s pricing, those extra input tokens are expensive. Multiply that by:

• 10 developers
• Each running 5–10 sessions per day

…and you’re looking at thousands of dollars per month in wasted context.

Three Concrete Ways to Cut Costs Today

1. Use a dependency graph for context selection

This is the highest-leverage change.

Instead of keyword-based file selection, route context through a dependency graph that returns only structurally connected code.

For Claude Code, that means adding vexp as an MCP server and using its run_pipeline tool.

At a high level, the flow becomes:

1. Developer describes the task.
2. Agent calls run_pipeline.
3. vexp:

• Traverses the dependency graph
• Builds a compressed context capsule
• Returns only the relevant code + impact analysis

1. Agent works from that focused capsule instead of a raw file dump.

The result: 65–70% fewer input tokens without sacrificing necessary context.

2. Add session memory so you stop re-explaining context

Every fresh session has a hidden tax:

• The agent re-reads the same files.
• It re-derives the same architectural patterns.
• It re-learns the same invariants and conventions.

Session memory (built into vexp) changes this:

• Observations from previous sessions are stored.
• Relevant past insights are surfaced automatically.
• The agent doesn’t pay the token cost to “re-understand” the same code.

Per session, this might only save 5–10% on startup. But across dozens of sessions per week, it compounds into meaningful savings and faster warm-up.

3. Use the run_pipeline single-call pattern

Many agent setups do multiple context-gathering calls:

• One for dependency graph
• One for session memory
• One for related context or search

Each call has overhead and often repeats work.

vexp’s run_pipeline collapses this into one MCP call that returns:

• Context capsule (relevant code)
• Impact analysis
• Session memory
• Related observations

In practice, this pattern uses about 60% fewer tokens than a multi-call equivalent and simplifies your agent logic.

Scaling This to a Team