The Meter on the Mind

#The Day Thinking Got a Price Tag

For most of computing history, thought was free. Not the salary of the person thinking, that was always expensive, but the act of reasoning itself cost nothing per unit. A developer could stare at a wall for an hour, try ten approaches, throw nine away, and the marginal cost of that mental churn was zero. Compute was a fixed cost you amortized. Thinking was unmetered.

That just ended, and almost nobody clocked the moment it happened.

Sam Altman admitted in June that AI token costs became "a huge issue" in 2026, an issue that, in his words, simply did not exist at the start of the year. People were happy with what they spent, and then suddenly they were not. The meme going around enterprises captures it perfectly: "My company spent its entire 2026 budget in Q1. Can you make this more efficient?" Uber burned its full year of AI coding budget in four months and capped tools at $1,500 a month. Microsoft started cutting direct Claude Code licenses as per-engineer agent bills hit $2,000 a month. OpenAI's single heaviest internal user now burns 100 billion tokens a month, and an independent tool author reportedly burns six times that.

A developer streamer, ThePrimeagen, watched this happen and made a prediction that came true in eight days: companies that told everyone to use all the tokens they wanted would slam the door and start asking who was being efficient. He then made five more predictions about where token economics goes next. They are sharp and mostly correct. But I want to argue they are all symptoms of something larger, and the larger thing is what we should actually be staring at.

We did not just make AI expensive. We turned cognition into a metered utility. And every metered utility, without exception, eventually gets gamed.

#The Mistake We Already Made, at a New Layer

Here is the part that should give anyone who has worked in software a cold feeling of recognition. We have run this exact experiment before. We called it lines of code.

The industry spent two decades learning that measuring developers by lines of code is poison. It rewards verbosity over clarity, volume over value, motion over progress. Every competent engineering leader knows this in their bones. It is the first instinct you are supposed to unlearn. I wrote about the most recent reincarnation of this disease in the token maxxing teardown: companies building leaderboards that rank engineers by tokens burned, mistaking consumption for contribution.

Now layer ThePrimeagen's five predictions on top and watch the pattern complete itself. Token budgets and stipends per employee. Token poker, where a team sits in a room and bids on how many million tokens a feature will cost, Agile reincarnated as a haggle over compute. Org-wide and team-wide budgets that turn one heavy user into the person the whole team quietly resents. Pair prompting, two engineers hunched over one context window to avoid waste. And the darkest one, rewarding the engineers who produce the most code with the most token budget, which is to say, handing unlimited ammunition to whoever fires the most rounds.

Strip the jargon and every one of these is the same move: pick a number that is easy to measure, make it the target, and watch human behavior deform around it. This is Goodhart's law, the iron rule that when a measure becomes a target it stops being a good measure. What makes the AI era genuinely new is the part most people miss. Gaming a metric used to require effort. You had to deliberately pad your code, inflate your commits, sandbag your estimates. With agents, gaming the metric is the default behavior of the tool. The slop arrives whether you intend it or not. You point an always-on agent at a problem and it generates volume as a byproduct of simply running. The corruption of the metric is no longer a choice. It is the resting state.

#The Slop Cannon Problem

George Hotz put the consequence more bluntly than anyone: the adoption of AI agents into software development will be "one of the most costly mistakes in the field's history." His reasoning is the uncomfortable core of this whole story. Strong engineers can look at agent output and see what is wrong with it. Weak engineers cannot. And it is precisely the weaker engineers who will produce ten times the volume, because the tool makes volume effortless and the metrics reward it. The average quality of the codebase degrades at scale, and the larger the organization, the worse it gets, because large organizations are mostly made of average performers doing average work, now armed with a machine that turns a vague intention into two thousand lines in a minute.

Connect that to the fifth prediction and you get the doom loop in one sentence. If you reward the highest producers with the biggest token budgets, you are systematically routing the most compute to the people least able to tell good output from bad. You are not scaling your best thinking. You are scaling your most confident output. Those are not the same thing, and a metered system cannot tell the difference, because the meter only counts tokens, and tokens are not thought.

#What the Meter Cannot See

This is where the crystal ball gets philosophical, so let me say the thing plainly. The best engineers I have ever worked with were not the ones who wrote the most code. They were the ones who deleted it, who found the one-line fix under the hundred-line problem, who sat quietly and thought until the complexity collapsed. In a world where thinking was free, that was invisibly subsidized. The slow, careful, token-light path and the fast, sprawling, token-heavy path cost the company the same: one salary. The meter erases that subsidy. For the first time, the engineer who thinks before acting is cheaper on a line item a finance team can see, and the engineer who lets the agent churn is a visible cost center.

That should be good news. In theory, the meter finally puts a price on waste. But here is the trap, and it is the whole point. A meter measures consumption, not value. It can tell you Timmy burned 100 million tokens and Brian burned 10 million. It cannot tell you that Brian's 10 million prevented an outage and Timmy's 100 million generated four dashboards nobody asked for. The moment you manage to the meter, you optimize for the thing the meter can see, and the thing it can see is exactly the wrong thing. We are about to spend twelve months relearning, at enormous expense, that you cannot meter cognition without corrupting it, the same way you could never count lines of code without corrupting them.

#The Fork I Actually See

So here is my prediction, in the same spirit, staring into the same glass. The companies that win the next two years will not be the ones with the biggest token budgets or the cleverest token-poker rituals. They will be the ones who refuse to make the meter the target. They will treat tokens the way a good engineering org treats cloud spend: a cost to be understood, not a scoreboard to be topped. They will measure outcomes that are hard to game, shipped reliability, problems that stayed solved, complexity that went down, and they will tolerate the engineer who burns almost nothing because she thinks first.

And somewhere out there, exactly as ThePrimeagen predicts, a company is going to do the opposite so thoroughly that it codes itself into the ground, rewarding its loudest slop cannons with infinite budget until the weight of the generated debt collapses the whole thing. That company will fail not because AI failed, but because it confused the meter for the mind.

The good news hidden in all of this is the oldest news in engineering. The best thinkers were always the ones who used the least. The meter did not change that. It just, finally, put it on the invoice.