Software engineering has long relied on artifacts to approximate output. Commits, pull requests, lines of code — imperfect proxies, sure, but usable ones. That model worked when code was written linearly by humans.
It no longer does.
The Commit Is Not Where Work Happens Anymore
AI-assisted development doesn’t just accelerate coding. It restructures how production works entirely.
The commit is now where work is recorded — not where it happens. What version control captures is the final selection, not the process that produced it. And confusing those two things leads to a fundamental measurement error: evaluating output at the point of integration rather than at the point of generation.
The real unit of work has moved upstream. It’s measured in tokens.
Code Is Now Sampled, Not Authored
In an AI-native workflow, a developer doesn’t write code directly. They prompt, iterate, filter, and select. Every completion expands the search space of possible solutions. Most of that exploration never reaches version control.
A single accepted change might be the product of thousands of tokens generated and discarded. Entire branches of possibility are explored and abandoned. From the perspective of commits, this effort is invisible. From the perspective of the system, it’s the dominant cost.
What we call “writing code” is increasingly the act of navigating generated space — not producing it from scratch.
Software Development Is Now a Throughput System
This reframing matters.
Tokens represent production capacity. Developers act as filters — selecting, validating, refining. The commit becomes a compression point: the reduction of a large exploratory process into a stable, shippable artifact.
The bottleneck shifts accordingly. The constraint is no longer how quickly code can be written. It’s how efficiently good outputs can be identified and validated.
Two engineers with identical commit histories could be operating entirely different systems — one exploring narrowly, the other running high-volume generation to converge on solutions faster. The commit log cannot tell you which is which.
Commit-Based Metrics Can Actively Mislead
If tokens are the new throughput, then what actually drives performance breaks down into three factors:
- Compute — how much can be generated
- Interfaces — how effectively that generation can be steered
- Judgment — how quickly the system converges on what’s good
Commit counts reflect none of these directly. In fact, they can invert reality. A system producing fewer, cleaner commits might look efficient while severely limiting exploration. A higher-throughput system might produce fewer commits while solving harder problems, faster.
The visible output shrinks as underlying capacity expands.
A New Optimization Problem
The economics of software production are changing too.
It’s no longer dominated solely by human time. Compute cost — expressed in tokens — is now a real input. That introduces a new class of optimization problem: how to allocate token budget across exploration, iteration, and validation.
The relevant questions shift:
- Not “how fast can this be coded” — but “how much exploration is enough?”
- Not “how many commits were made” — but “how efficiently were tokens converted into working software?”
This isn’t just an engineering question. It’s a resource allocation problem.
Where Productivity Actually Lives
At its core, software development is becoming an infrastructure system. There are inputs (compute, prompts), transformation layers (models, tools), and filters (developers, validation pipelines). The efficiency of the whole depends on how well these layers convert tokens into reliable output.
Commits sit at the end of this pipeline. They record decisions — not work.
As AI generation scales, more of the real effort moves upstream: into exploration, steering, and filtering. That’s where the system operates. That’s where productivity is actually determined.
The transition from commits to tokens isn’t just a change in metrics. It’s a change in how software production should be understood.
Tokens measure what the system can produce. Commits measure what was accepted. Conflating the two obscures the real constraint.
In an AI-native system, throughput is no longer bounded by how much code a human can write. It’s bounded by how effectively tokens are turned into working software.
And that changes almost everything about how we should measure the people building it.