A new way of measuring developer success has emerged in Silicon Valley. It is not about code quality. It is not about problems solved. It is about tokens. Specifically, how many a developer consumes per day. The higher the token budget, the greater the badge of honor. This phenomenon is becoming known as tokenmaxxing, and the data suggests that it is one of the most expensive mistakes in modern software development.
Tokens are the basic units that AI tools such as Claude Code, Cursor, and GitHub Copilot use to read, write, and reason about code. The logic behind tokenmaxxing is that more tokens equal more output, more productivity, and more impact. But the data disproves this.
What the analysis found
The analytics platform Jellyfish analyzed more than 12,000 developers across 200 companies during the first quarter of 2026. It found that a typical developer consumes approximately 51 million tokens per month. An experienced developer consumes more than 380 million per month, over seven times as many.
What do they get in return? A developer in the lowest tier of token spending spent just under 3 dollars over the entire first quarter and submitted an average of 11 approved requests to merge code (pull requests). A developer in the highest tier spent 1,822 dollars and submitted an average of 23 pull requests. Costs increased roughly 600-fold, but output only doubled.
The cost per merged pull request ranges from 28 cents for the lowest group of users to 89 dollars for the highest. Tokens therefore do not behave like a linear input. They behave more like rocket fuel: going faster is possible, but it requires exponentially more resources.
The illusion of working code
The problem is not just the cost; it is what happens to the code after it is accepted. Alex Circei, founder and CEO of the analytics company Waydev, which tracks more than 10,000 software engineers across 50 customers, describes a paradox that he sees among managers time and again.
Managers boast about an 80 to 90 percent code acceptance rate. That figure looks great. But they overlook what comes after acceptance: developers have to return to that code over the following weeks and rewrite it. The actual acceptance rate, after subtracting rewritten code, falls to 10 to 30 percent of the amount originally generated.
In its report from January, GitClear found that developers who actively use AI exhibit a 9.4 times higher rate of so-called code churn than their colleagues who do not use AI. Code churn refers to code that is written and then soon rewritten or deleted. In its March study, which included data from 22,000 developers across more than 4,000 teams, Faros AI identified an 861 percent increase in code churn when AI tools were used heavily.
Misleading metrics
Developers have debated productivity metrics for decades. It started with lines of code. Then came commits, pull requests, and deployment speed. Sooner or later, every metric proved inadequate because it encouraged people to optimize the metric itself rather than the actual output.
Tokenmaxxing is a continuation of the same logic. Token consumption is an input into the process, not an output. Measuring it as an indicator of productivity makes sense only if you want to encourage greater adoption of AI tools, or if you sell tokens. For a manager who wants to know whether their team is working efficiently, it is a misleading figure.
The problem also varies according to a developer's experience. Junior programmers accept significantly more AI-generated code than their more experienced colleagues. And it is precisely they who then face a greater volume of rewriting. Experienced developers fare better because they can recognize where AI-generated code reaches its limits and proactively fix it before it reaches review.
The point of true efficiency
Based on the data, Jellyfish identified what it calls the "sweet spot" of the token usage curve. The highest return does not come from a small group of developers with extremely high token consumption. It comes when as many people as possible across an organization use AI tools consistently and in moderation. Such an approach delivers significantly more value than a handful of "tokenmaxxers" operating at full capacity.
This also explains why many teams have not yet fully turned the promise of autonomous AI agents into reality. Such systems can deliver major leaps in productivity, but they require solid infrastructure: isolated testing environments, orchestration, and so-called context engineering. Without this infrastructure, the efficiency barrier cannot be overcome simply by increasing token consumption.
An old problem
TechCrunch mentions in its Equity podcast that the gap between those who truly understand AI and everyone else is widening. And new vocabulary such as "tokenmaxxing" only highlights this gap. While some debate whether consuming 380 million tokens per month is reasonable, others are still struggling to work out how to properly integrate AI tools into their workflow at all.
Due to the rise of fast AI tools, Waydev has completely redesigned its platform over the past six months and released new analytics tools that track AI agent metadata, namely the quality and cost of their code. Atlassian recently acquired the similarly focused startup DX for a billion dollars to help customers understand the actual return on their investments in AI agents. The market for developer analytics tools is growing rapidly precisely because AI tools themselves do not provide this insight.
As Circei says: "This is a new era of software development, and you have to adapt. It is not a passing wave that will fade away." But adapting does not automatically mean consuming more tokens. It means learning to consume tokens intelligently.
