Your AI Coding Agent Is a Junior Hire, Not a Genius — Manage It Like One
A post doing the rounds this week reports a developer burning roughly 2 billion tokens in a single day across a fleet of coding agents — and, by his account, paying a small fraction of what list API prices would suggest. The comments under it weren't arguing about the numbers. They were asking the same question: how do you organise that much agent work without it turning into very expensive noise?
The answer is unglamorous, and it is the same one every team that runs agents at volume eventually lands on: management.
Your coding agent is not a genius colleague. It is a very fast junior hire who never sleeps, never asks a clarifying question unless forced to, and will happily burn an afternoon confidently doing the wrong thing. Treat it like one and it becomes the best hire you ever made. Treat it like an oracle and it becomes your most expensive mistake.
1. Give it a job description, not a wish
"Build me a dashboard" is a wish. A junior hire given that wish will guess — and guess wrong in ways you only discover later.
A job description has three parts: the task, the boundaries, and the definition of done. Write all three before the agent starts:
- Task: one outcome, small enough to verify in a minute. "Add a
/healthendpoint that returns 200 and the app version" beats "improve the API." - Boundaries: which files it may touch, which it must not, and what it must never do without asking (migrations, secrets, deleting data).
- Definition of done: the exact checks that must pass — tests green, lint clean, types check. If you can't state it, the agent can't know it either.
Small tasks have a second benefit: they cap the blast radius. A bad 20-line change is a revert. A bad 2,000-line change is a weekend.
2. Write the SOP once, reuse it forever
The single highest-leverage file in an agent-driven repo is the instructions file the agent reads every time — CLAUDE.md, AGENTS.md, or your tool's equivalent. This is where management becomes a system instead of a repeated conversation.
A good one is short, specific, and enforceable:
# Project rules - Run `npm test` and `npm run lint` before marking any task done. - Never edit files under `migrations/` without asking. - Keep functions under 40 lines; extract helpers instead. - If a test fails twice in a row, stop and report — do not retry blindly. Notice what this does: it moves your judgement out of your head and into a file the agent cannot forget. Every new agent session starts with the same rules, the same checks, the same bar. That is onboarding, and it costs you twenty minutes once.
Update the file whenever an agent makes a mistake you had to correct. Each correction is a rule the next hundred sessions will follow for free.
3. Verification is the manager's job
An agent that marks its own homework will pass itself every time. The verification step belongs to you — or rather, to a check the agent cannot argue with.
Make every task end with the same loop, and make the loop mechanical:
# No task is "done" until this passes npm run lint && npm run typecheck && npm test Tests, type checks, and linters are not bureaucracy here; they are the review meeting. An agent that writes code and then runs the suite is an agent that catches its own regressions before you ever see them. An agent that skips that step will hand you green-looking code with a broken build.
For anything that matters — auth, payments, data deletion — add a human review gate. The agent proposes, you approve the diff. That gate is not a lack of trust in the tool; it is the same gate you would put in front of any junior's first pull request.
4. Route work to the right brain
Not every task deserves your strongest model. Formatting, boilerplate, renaming, simple refactors, and summarising logs are bulk work: fast, cheap models handle them well. Architecture decisions, hard debugging, and security-sensitive code are judgement work: that is where the frontier model earns its price.
A routing rule of thumb, as a sketch:
def pick_model(task): if task.kind in ("format", "boilerplate", "simple-refactor"): return "fast-cheap-model" # bulk work, low stakes if task.kind in ("architecture", "hard-debug", "security"): return "frontier-model" # judgement work, high stakes return "balanced-model" The exact model names matter less than the habit: decide the tier by the task, not by default. Teams that route deliberately routinely find that most of their token volume is mechanical work that never needed the expensive model at all.
Two more levers stack on top of routing. First, caching: the repo context, system prompt, and instructions your agent re-reads every session are the same text over and over — prompt caching turns that repetition from a cost into a discount. Second, batching: five similar small tasks in one session share context; five separate sessions pay for it five times.
5. Count results, not tokens
The easiest trap in agent work is optimising the wrong number. Token counts feel precise and managerial. They are not the work. The work is accepted diffs, passing tests, and shipped features.
Before you scale up agent usage, pick three numbers that actually describe output:
- Tasks completed per week, as verified by your checks — not tasks attempted.
- Revert rate: how often agent-written code gets rolled back or heavily rewritten.
- Time from task to merged: where does it actually get stuck?
If tokens go up and these numbers don't, you are not getting more productive. You are token-maxxing — producing motion instead of software. The developer in that viral post was not celebrating the 2 billion tokens. He was celebrating that the tokens turned into audited, checked-off work at a cost he could afford. The tokens were the input. The checklist was the product.
What changes on Monday
You don't need a platform, a budget, or a re-org to start managing agents properly. You need four things, and you can have them before lunch:
- One instructions file in the repo with your real rules.
- A definition of done — tests, lint, types — that ends every task.
- A routing habit: cheap models for bulk work, strong models for judgement work.
- A weekly count of completed, verified tasks — not tokens burned.
Agents don't self-manage. That's not a flaw in the tool; it's the job description. The developers getting the most out of them right now aren't the ones with the cleverest prompts. They're the ones who got good at being a manager.
— Davis George · zhuan.xyz

