Token Maxxing Is a Fad. The Best Engineers Use the Least.

#Lines of Code, Repackaged

The software industry spent two decades learning that lines of code is a garbage metric. It rewards verbosity over clarity, complexity over simplicity, volume over value. Every competent engineering manager knows this. It is the first thing you unlearn.

And then in 2026, the same industry reinvented the same mistake. They just called it tokens.

Token maxxing is the practice of maximizing AI token consumption as a proxy for productivity. Internal leaderboards rank engineers by how many tokens they burn through Claude Code, Cursor, Codex, or whatever tool their company has standardized on. The more tokens you consume, the higher your score. The higher your score, the more productive you look.

It is lines of code thinking for the agentic era. And it is already collapsing under the weight of its own absurdity.

#The Leaderboard Era

Meta built an internal leaderboard called Claudeonomics,named after Anthropic's Claude, which Meta employees use heavily despite the company having its own Llama models. The leaderboard ranked all 85,000 employees by token consumption, spotlighting the top 250 as super users. It awarded titles like "Token Legend" and "Session Immortal." In a single 30-day window, total usage on the dashboard exceeded 60 trillion tokens.

Sixty trillion tokens. In one month. At one company.

Meta CTO Andrew Bosworth defended it publicly, stating that a top engineer spending salary-equivalent on tokens achieved 10x productivity. The leaderboard was designed to normalize AI usage and identify power users.

What it actually did was incentivize employees to leave AI agents running for hours executing pointless research tasks to inflate their position on the board. Consuming tokens while producing nothing of value. After backlash on social media, Meta scrapped the leaderboard.

Amazon followed the same playbook. The company set targets for more than 80% of developers to use AI tools weekly and launched an internal leaderboard called Kiro Rank that tracked and scored employees on how much they used the tools. Employees openly admitted to using AI unnecessarily to pump up their usage scores. One Amazon employee told reporters there was "just so much pressure to use these tools." They instructed AI agents to perform non-essential tasks specifically to hit metrics.

Amazon's SVP of Engineering acknowledged the leaderboard was created with good intentions but that tokenmaxxing had inflated costs without improving outcomes. Amazon scrapped the leaderboard. The company told engineers: "Don't use AI just to use AI."

Uber's version was less formal but more expensive. The company incentivized Claude Code adoption through internal rankings. Adoption jumped from 32% to 84% of its 5,000 engineers. Monthly per-engineer API costs ranged from $500 to $2,000. Uber burned through its entire 2026 AI coding tools budget in four months.

Uber COO Andrew Macdonald publicly admitted the company cannot draw a clear line between its surging AI token spend and measurable improvements in consumer products. Ninety-five percent of Uber engineers now use AI tools monthly. Seventy percent of committed code is AI-generated. And the COO cannot justify the cost.

Nvidia CEO Jensen Huang poured gasoline on the fire: "If an engineer earning $500,000 a year hasn't spent more than $250,000 on tokens by year-end, I would be very worried." Half your salary on tokens. As a floor, not a ceiling.

This is the culture that token maxxing built.

#The Data Says It Does Not Work

Jellyfish, which tracks engineering productivity across thousands of organizations, collected data on 7,548 engineers in Q1 2026. The findings should have killed the leaderboard era before it started.

Engineers with the largest token budgets produced the most pull requests. That sounds like validation. Until you look at the cost curve. They achieved two times the throughput at ten times the cost of tokens. A 2x productivity gain for a 10x cost increase is not a win. It is a loss that looks like a win on a dashboard.

The code acceptance numbers are worse. Engineering managers report 80-90% acceptance rates for AI-generated code. That is the number that shows up in the metrics. But Jellyfish found that engineers return to revise that accepted code far more often than before. The real-world retention rate,code that actually stays in production without significant rework,drops to 10-30%.

Read that again. 80-90% of AI-generated code gets accepted. 70-90% of it gets revised later. The initial acceptance rate is a vanity metric. The revision rate is the real number. And nobody tracks the revision rate on a leaderboard.

TechCrunch summarized it cleanly: tokenmaxxing is making developers less productive than they think.

#What Intentional Engineers Actually Do

The engineers who are genuinely productive with AI tools do not show up on leaderboards. They do not consume the most tokens. They consume the fewest tokens per unit of shipped value.

This is the zero waste approach. Code with intent. Prompt with precision. Ship what matters.

Specification-driven development is the core practice. A good specification compresses intent. It gives the AI agent a stable source of truth that is easier to break into smaller execution steps. The specification is the work. The token consumption is the implementation detail.

CostLayer published research showing that semantic prompt specificity reduces AI agent token waste by 74%. From 8,200 tokens per query to 2,100 tokens per query. Same outcome. A quarter of the cost. The difference is not the tool. The difference is the intent behind the prompt.

The best engineers I work with share a set of habits that look nothing like token maxxing.

They write the spec before they prompt. They know exactly what they want the AI to produce before they ask it to produce anything. The prompt is a deployment of a decision, not a search for one.

They constrain the context window. They do not dump the entire codebase into context and hope the model figures it out. They select the specific files, the specific functions, the specific interfaces that are relevant. Smaller context means less noise, better output, fewer tokens.

They validate through output, not input. They do not line-by-line audit every generation. They write tests first, run QA against the intended behavior, and verify through UAT that the output does what the spec said it should. If the tests pass and the acceptance criteria are met, the code ships. If they do not, the prompt gets rewritten. The validation is in the outcome, not the reading.

They throw away bad output immediately. If the first generation is wrong, they do not iterate on a broken foundation. They rewrite the prompt. They change the approach. They start over. Iterating on garbage is the most expensive form of token waste because it compounds: each follow-up prompt carries the context of the mistake.

They route intelligently. Not every task needs the same model or the same depth of context. A boilerplate CRUD endpoint does not need the same token investment as a complex state machine. The best AI-first engineers match the weight of the tool to the weight of the problem. Cheap models for commodity tasks. Expensive models for hard reasoning. No model at all for a two-line config change that takes less time to type than to prompt.

None of these habits show up on a token consumption leaderboard. All of them show up in the quality of the shipped product.

#The Goodhart Problem

Goodhart's Law states that when a measure becomes a target, it ceases to be a good measure.

Token consumption was originally a reasonable proxy metric. High token usage could indicate high AI adoption, which could indicate engineers leveraging powerful tools effectively. The logic was not crazy.

But the moment token consumption became a leaderboard, a ranking, a target, a measure of productivity, it stopped measuring what it was supposed to measure. Engineers optimized for the metric instead of the outcome. Agents ran idle. Unnecessary tasks were invented. Tokens were burned for the sake of burning tokens.

This is not a hypothetical failure mode. It happened at Meta. It happened at Amazon. It happened at Uber. It happened at the three companies with arguably the most sophisticated engineering cultures on the planet.

If they could not make token leaderboards work, nobody can. The metric is structurally broken.

#The Real Cost

The direct financial waste is the easy number to point at. Uber's budget burned in four months. Meta's 60 trillion tokens in 30 days. Amazon's inflated usage scores driving up compute costs.

But the harder cost is cultural. Token maxxing creates an environment where volume is valued over craft. Where speed is celebrated over correctness. Where the engineer who ships 50 pull requests a week is rewarded more than the engineer who ships 5 that actually work.

This is the exact same pathology that lines-of-code metrics created in the 2000s. The industry spent a decade recovering from it. We built entire frameworks,DORA metrics, lead time, deployment frequency, change failure rate,specifically to move beyond volume metrics.

And then we went right back.

The Jellyfish data makes the cost concrete. If 70-90% of accepted AI-generated code needs revision, and your engineers are producing 2x the volume, your team is not 2x more productive. Your team is producing 2x the output that needs to be revised. You have doubled the work without doubling the value.

The revision cycle is invisible in most dashboards. PR counts go up. Story velocity goes up. Sprint completion rates go up. Every metric that a manager reports to leadership improves. But six months later, the codebase is harder to maintain, the bug count is higher, and the senior engineers are spending their time cleaning up AI-generated code instead of building new features.

This is not a prediction. This is what Jellyfish measured across 7,548 engineers.

#What Comes After the Fad

The leaderboards are already being scrapped. Meta killed Claudeonomics. Amazon killed Kiro Rank. The Seoul Economic Daily reported that Big Tech is broadly moving away from AI usage leaderboards amid the tokenmaxxing backlash.

What replaces them matters more than what they measured.

The right metric is not tokens consumed. It is not PRs merged. It is not code acceptance rate. It is value delivered per token spent.

Value delivered is hard to measure. That is why everyone defaults to token counts,they are easy. But easy metrics that measure the wrong thing are worse than no metrics at all because they actively drive bad behavior.

The organizations that figure this out will measure outcomes, not consumption. They will track: how many production incidents did this code cause? How many times did this code get revised after merge? How long did it take from prompt to production-ready code, including all revision cycles? What is the total cost of ownership of this feature, including the AI costs, the review time, and the maintenance burden?

These are harder to instrument. They require connecting the AI usage data to the production data to the incident data. Most organizations cannot do this today. But the ones that build this instrumentation will have an actual picture of AI productivity instead of a leaderboard that measures waste.

#The Zero Waste Manifesto

Token maxxing is a fad. It is already dying. The organizations that embraced it are already walking it back.

What survives is the opposite: zero waste engineering. Intentional prompting. Specification-driven development. QA-driven validation. Intelligent model routing.

The best engineer on your team is not the one at the top of the token leaderboard. It is the one who ships reliable, maintainable code using exactly as many tokens as the problem requires and not one more.

Half your salary on tokens is not a productivity strategy. It is a Nvidia sales pitch dressed up as engineering wisdom.

The companies that win the agentic era will not be the ones that burned the most tokens. They will be the ones that turned tokens into outcomes with the least waste and the clearest intent.

Code with intent. Prompt with precision. Ship what matters. And stop measuring the wrong thing.