The annual bill for AI tokens is starting to rival engineering payroll at some companies, and leadership does not know whether to celebrate or panic. Enterprises have spent the last few years shoveling capital into large language models, expecting that cheaper inference would automatically translate into smaller headcounts and faster shipping cycles. Instead, many engineering organizations find themselves paying twice: once for the talent they hoped to augment, and again for the compute that was supposed to replace them. The question is no longer whether AI can write code. It is whether the code it writes justifies the fortune being burned to produce it.
The Half-Salary Benchmark
Jensen Huang laid the math out bluntly at the close of GTC 2026, speaking on the All-In Podcast. The Nvidia CEO proposed measuring an engineer’s efficiency by comparing their salary directly to their AI token consumption. His threshold was stark. Take a software engineer earning $500,000 a year. If that engineer uses less than $250,000 worth of tokens annually, roughly half their salary, Huang considers it a warning sign. Leadership should be "deeply alarmed," in his words, not because the company is overspending on people, but because it is likely underutilizing them.
The logic flips the traditional cost-control mindset. For years, finance teams treated compute as a variable expense to be minimized. Huang argues the opposite. An expensive engineer who barely touches a model is an expensive engineer operating without a force multiplier. The expectation is that high-cost talent should act as a funnel, pushing enormous volumes of work through AI systems, reviewing the output, and orchestrating the results. Low token spend does not signal thrift. It signals that the human is still doing the mechanical work a model could have handled.
What That Spend Looks Like in Practice
To understand why this benchmark matters, consider what $250,000 in tokens actually represents. At prevailing rates for frontier models, that is not a few autocomplete suggestions. It is millions of tokens processed every working day across a wide range of tasks. It suggests an engineer who is not merely accepting editor completions but is running extensive architectural reasoning, bulk refactoring through intelligent agents, automated testing pipelines, synthetic data generation, and iterative design exploration.
A senior engineer working this way might chain together multiple model calls for a single feature: generating scaffolding, analyzing dependencies for breaking changes, simulating edge-case behavior, and producing documentation in parallel. The throughput is massive because the human is no longer typing every line. They are steering. For Huang, the salary justifies itself only when the human operates at that scale, multiplying their output through relentless model interaction.
Where the Returns Go Missing
Despite this vision, the industry is staring at a widening gap between infrastructure spending and delivered results. Companies have rushed into token-heavy strategies, provisioning enterprise contracts with AI vendors and retrofitting their development pipelines around generative tools. The capital expenditure has been staggering. The productivity returns, for many, have been underwhelming.
Developers are indeed faster at the boring stuff. Boilerplate code, unit test skeletons, and repetitive CRUD operations fly by when a model generates the first draft. But software engineering was never really about typing speed. The hard, expensive work lies in maintaining sprawling systems, reasoning through distributed failure modes, ensuring security across layered dependencies, and managing the technical debt that every shortcut accrues. These