Task 18a of ParkEase was the admin API: refunds, approvals, the ledger explorer. Important, money-adjacent, worth reviewing carefully.

It was reviewed so carefully that it used up most of my weekly usage limit before it was finished.

What happened

My workflow said: for each sub-task, dispatch an implementer agent, then a reviewer agent, then a re-reviewer for whatever the reviewer found. And for review, fan out single-lens specialists: security, TypeScript, database, silent failures, test coverage.

Every one of those is a separate agent. And every separate agent starts from nothing. It doesn't share the main session's context; it has to read the task, the rules, the files and the diff again before it can do anything.

On that one task, roughly 40 agent dispatches, each costing somewhere between 60,000 and 290,000 tokens just to rebuild what the main session already knew.

The review quality was excellent. The bill was absurd.

Why it's easy to fall into

Multi-agent setups look like the "serious" way to work. Parallel specialists, independent reviewers, no single point of failure. And for some problems they are.

But the cost model is counter-intuitive. An agent's price isn't the work it does. It's the context it has to load to do the work. Ten reviewers on a 200-line diff don't cost ten times a review; they cost ten times understanding the project, plus the review.

What I changed

The correction became a permanent rule:

  • Work inline by default. The main session already has the context; use it.
  • One review pass over the diff by the main session, with the tests as evidence.
  • At most one cheap specialist for a security-critical diff, on a smaller model, and only after saying what it'll cost.
  • Batch tool calls, read only the lines you need, never paste huge outputs into context.
  • Say up front roughly what a heavy step will cost, and let the human choose.

There was an earlier, milder warning I should have listened to: the very first rollout of always-on subagents used more than half a million tokens before I said "lean". The full lesson took one more, much bigger, bill.

The quality didn't drop

That's the part worth saying clearly. After the change, tasks shipped with the same gates: tests first, verification before "done", security review on money paths, the full pre-PR checklist. The specialists still exist and still run when a diff deserves them. What went away was reflexive fan-out.

Thoroughness isn't the number of agents you run. It's whether the right check ran on the right code.

Next: another way to cut context costs. Querying a knowledge graph of the codebase instead of grepping it ten times.

ParkEase is a peer-to-peer parking marketplace for India, built solo with Claude Code.
Code: https://github.com/Deonkar/parkease