It is the difference between giving an LLM an epic and say "You figure it out" and giving the single tasks' breakdown you envisioned and build incrementally on top of it.

With the latter you can, for example, say "Wait, this should be an interface because later on we need different concrete implementations". With the former, the agent doesn't do that, gets to the point where you actually need the flexibility interfaces give you and refactors everything to handle that. That is at least 2x the work/tokens. Multiply this for all the decision points you have to do to deliver a big piece of work and you have your bagillion tokens consumed.

Work on a project where you can verify the functionality instead of reviewing the code in any detail.

Use worktrees to parallelize development on multiple tasks.

That's all there is to it.

In many cases, this means a new solo project rather than a project at work with a team.

In my iOS app with around 100k LOC, Claude Code typically uses 150k context for small tasks.

For tasks that take longer and run the tests to instrument and investigate outcomes, the context grows to 250k-600k. With a few of those in parallel, busy days can consume a lot of tokens.

Very large context windows (usually when you're working on a very large existing project) will chew through tokens quickly. So will RAG.

If you're working on isolated components within a system or small projects, you'll have a very different experience.

Working on multiple things at the same time. If you've got 4-5 instances running simultaneously you'll burn 4-5 times as many tokens.

because they don't know what they're doing.