Software engineering has always chased the wrong productivity metrics. Managers counted lines of code. Agile teams tracked story points. None of it reliably measured whether a developer was thinking clearly or simply typing a lot. Nvidia CEO Jensen Huang thinks he has a better gauge, and it has nothing to do with keyboards. During a recent appearance on the All-In Podcast following GTC 2026, Huang argued that the real measure of a modern engineer’s value is how many AI tokens they consume relative to their salary. The message was direct: if you earn half a million dollars a year but spend less than half that on large language model services, you are probably failing to use the tools that justify your paycheck.

A Hard Ratio

The metric Huang described is jarringly simple. Take an engineer’s annual compensation. Compare it to their yearly tab for LLM API calls, fine-tuning runs, and agentic inference. If a highly skilled engineer earning $500,000 per year racks up less than $250,000 in AI token costs, Huang sees a problem. It suggests the developer is either working in isolation from modern assistance or treating AI like a glorified search engine rather than a genuine collaborator.

This is not a license for reckless spending. It is a test of load-bearing cognition. Huang’s premise is that elite engineers should offload as much mental drudgery as possible to the most capable models available. Debugging sessions that once sprawled across three days can compress into hours when a model holds the entire codebase in context. System design debates that used to require lengthy meetings can resolve through rapid prototyping with a reasoning model. For Huang, the $250,000 threshold is less a budget ceiling and more a floor. It represents the minimum intelligence subsidy a top-tier engineer should need to operate at full capacity.

Developers who fall below that line are doing too much of the work themselves. They trace bugs manually, write boilerplate by hand, and reread documentation that a well-prompted model could synthesize in seconds. In an era where inference costs are falling and context windows are expanding, frugality with tokens signals underutilization, not discipline. An engineer who fails to aggressively utilize AI to augment their output is, by this logic, underperforming.

Tokens as a Proxy for Leverage

Traditional engineering management loves tangible output. Jira tickets closed. Commits pushed. Features shipped. These numbers feel safe because they are countable. Huang’s framework largely discards them. Under his logic, a senior staff engineer might produce fewer raw commits than a mid-level hire while generating far more value, because their real product is decisions. Tokens become the ledger for those decisions.

When an engineer spends heavily on LLM inference, they are not merely buying text generation. They are buying parallelized thought. A $500,000 engineer throwing massive context windows at a refactoring problem is essentially running a dozen simultaneous cognitive threads, checking edge cases across microservices, and stress-testing architectural assumptions without yet writing a single line of production code. The tokens convert salary hours into compressed outcomes. They purchase speed, architectural foresight, and debugging capabilities that would otherwise eat hundreds of manual hours.

This flips the old incentive structure. Engineering leaders have historically negotiated hard for cloud compute discounts and treated SaaS procurement as a cost center to minimize. Huang suggests that mindset is backwards for AI. The token budget should scale with talent. If you hire expensive brains and then starve them of the most expensive models, you trap them in manual workflows. They become high-priced typists. The goal is what Huang implies is intelligence density: maximum applied cognition per human hour, even if the cloud bill looks alarming at first glance. If an engineer is not consuming enough tokens to justify their high compensation, they are likely failing to offload the cognitive heavy lifting to AI, thereby limiting their potential impact on the organization.

Keep the Team, Expand the Compute

Rising operational costs usually trigger headcount reviews. CFOs see ballooning API bills and reflexively ask who can be cut. Huang offers the opposite prescription. Instead of shrinking the team to fit a budget, companies should optimize the budget to empower the team.

这一论点的核心在于替换成本和协调开销。一家传统的软件组织可能会配备 30 名工程师来维护单体架构、互相审查 pull request 并缓慢地迁移服务。而一个由 5 名深度增强型工程师组成的小型团队，每人都在消耗企业级的 token 配额，其产出可能达到甚至超过前者。节省的成本并不在于 API 这一项支出本身，而在于消除了沟通延迟、招聘周期和官僚主义带来的阻碍。

只有当你雇佣那些能够有目的地引导大规模 token 流的工程师时，这一策略才会奏效。将堆栈跟踪（stack trace）粘贴到聊天机器人中的开发者，与那些能够编排多智能体流水线（multi-agent pipelines）、维护丰富的上下文库并严格验证幻觉输出（hallucinated outputs）的开发者之间，存在着本质的区别。后者更难寻找。这正是为什么 Huang 将这一指标与薪资挂钩的原因。高薪应与高水平的编排能力相关联。你支付 50 万美元并不是为了让某人每周给模型写一次提示词（prompt）。你支付薪水是为了让他们管理一个自动化推理生态系统，以史无前例的速度构建复杂的系统。

实践中的意义

对于工程组织而言，token 与薪资之比与其说是一项僵化的会计规则，不如说是一个文化衡量标准。领导者应该思考：他们薪资最高的开发者是否拥有足够的权限、培训和授权去积极地使用 AI？他们是在对遗留代码进行长上下文分析，还是仍在逐行使用 grep 检索日志？他们是在使用智能体编程工具（agentic coding tools）进行集成测试，还是在手动编写 mock？他们的项目瓶颈在于人力注意力，还是在于 API 的速率限制（rate limits）？

如果答案指向人力瓶颈，解决办法通常不是要求增加工作时长，而是提高 token 的上限。让工程师启动更多的智能体（agents）。让他们为整个服务网格（service mesh）保持一个持久的上下文窗口。让他们在一下午内进行 50 次架构迭代，而不是在一周内进行两次。当 token 消耗被视为高杠杆工程能力的体现，而非不必要的成本时，公司内部的授权机制就会发生改变。

当然，仅仅是投入资金并不能保证任何结果。将 token 浪费在琐碎的查询或范围模糊的提示词上纯属浪费。关键的纪律在于将大量的算力集中在具有高价值的问题上：跨服务设计、安全审计、用于遗留系统迁移的行为克隆（behavior-cloning），以及生成合成训练数据。精通这一目标的工程师会成为“乘数”。而那些不精通的人，无论薪资多高，看起来都只是在错误的方向上造成了高昂的成本。

核心启示

Huang 的论点归根结底在于重新定义 AI 支出。不要再将 LLM token 视为一种运营税，而应将其视为转化为工程交付速度（engineering velocity）的原材料。在这种框架下，那位工程师