I spent $25,507 on AI coding agents in twelve weeks

Akshat Jain spent $25,507 on AI coding agents over twelve weeks. That is the whole headline. Not a projection, not a pitch for a tool, just what the meter read after three months of building.

Two agents did the work: Codex and Claude Code. Between them they moved 34.2 billion tokens and produced about 2,250 commits. That is the raw shape of it. Big numbers, but numbers you can hold.

Before going further, the honest caveats, because they change how much weight any of this carries. These are ccusage estimates derived from model pricing, not a bill from a provider. Commits are a rough proxy for output, not a clean measure of value. And the repo has a second contributor, so not every line traces back to one person and one agent. Keep all three in mind as you read.

The first instinct on seeing a number like this is to imagine it scattered across experiments, side quests, and half-finished toys. It was not. 95% of the spend went into a single codebase: the product he was building.

And almost all of that was production engineering. Feature work. QA. Onboarding flows. Deploys. Debugging. Not prompt-tinkering, not chatting with a model about ideas. The unglamorous middle of shipping software, done over and over.

If you are trying to reason about your own spend, this is the first useful divide. Money spent exploring is different from money spent building the thing you already decided to build. This was overwhelmingly the second kind.

Here is the part that surprises most people. The cost was not spread evenly across the work. It clumped. Of 596 sessions, the 20 largest accounted for 85% of all tokens. A small handful of runs ate almost the entire budget.

The single biggest run makes the point on its own. A $5,203 Codex session did exactly one job: open every page of the app in a browser and test it. That one session was 19% of the whole bill. One run, nearly a fifth of three months of spending, just to walk the product like a user and check that it worked.

This is worth sitting with. The expensive thing was not writing code. It was thorough, exhaustive verification. The agent did the kind of QA pass a human tester would do, except it did all of it, every page, without getting bored or cutting corners. That completeness costs tokens, and the tokens cost money.

Strip away the dollar figure and look at the actual shape of the activity, and it looks much more like ordinary engineering than like a chatbot conversation. By volume: 106,000 shell commands, 36,000 sed edits, 18,000 git calls, 15,000 ripgrep searches, and a couple thousand browser-QA passes.

Read that list again. Running commands. Editing files with sed. Committing with git. Searching the codebase with ripgrep. Checking the live app in a browser. These are the same moves a developer makes by hand, just done at a volume no person would sustain.

This is what people miss when they picture AI coding as one clever answer to one clever prompt. Real agentic engineering is mostly grinding: search, edit, run, check, commit, repeat, thousands of times. The intelligence shows up in the loop, not in a single brilliant reply.

Per unit of output, the work was cheap. About $11 per commit. Under two cents per net line of code. By those numbers, an individual commit or an individual line feels almost free, which is exactly the feeling that drives the total up.

That is the trap, and it has a name. As each token got cheaper, he used far more of them. Weekly usage grew roughly 7,800x between March and May. The price per unit fell, and consumption rose so much faster that the bill climbed anyway. This is Jevons Paradox, the old observation that making a resource cheaper to use often increases, not decreases, how much of it you burn.

So the cheap unit cost is not the reassuring fact it looks like. It is the engine. When each commit costs $11, you do not do fewer commits to save money. You do more of them, because each one is so affordable, and the aggregate is what shows up on the statement. Cheaper tokens did not produce a smaller bill. They produced a much larger appetite.

First, do not anchor on the total. $25,507 is what twelve weeks of full-time, near-continuous agentic engineering on one product costs at this point in time. If you are dabbling, fixing a bug here, generating a script there, your number will look nothing like this. The headline is a ceiling for a specific, intense way of working, not a typical monthly bill.

Second, expect your spend to concentrate. A few big, thorough runs, especially exhaustive QA passes that walk the whole app, can dwarf everything else. If you want to control cost, that is where to look first. Watch the long sessions, not the short ones. One careful browser-test run was a fifth of the entire bill here.

Third, and most important, plan for Jevons Paradox in your own usage. As the tools get cheaper, your instinct will be to do more, not to save. That is not a flaw to fix, it is just the dynamic to expect. The right question is never “can I afford this session.” It is whether the work a session produces is worth more than what it costs. If a $5,203 run finds the bugs across every page of your product before your users do, that may be a bargain. If it does not, no per-line price makes it cheap. Judge the output, not the unit price, and the economics stay legible.