Two theories of a programmer
The Studio build record shows a curve that doesn't look like a normal engineering chart. Understanding why it bends means answering a question most of the industry hasn't noticed it's being asked: what is a programmer for?
The theories
The old theory says a programmer is a person who types out the code they thought of. The new theory says a programmer is a person who exercises editorial judgment over a fleet that types. Every other difference in the data falls out of that one difference — the totals, the shapes, even what a “commit” means.
This isn’t a story about talent. It’s a story about what happens when you change your theory of the job, instead of only changing your tooling.
Read the shapes, not the totals
Nearly every engineering chart in the world is a metronome: a steady band of commits per week, team-wide, quarter after quarter. That is the signature of manual work — output is linear in hours, and hours are constant. Charts have looked like that for fifty years, and there is nothing wrong with it except the one thing that shape can never do: bend.
The most interesting line in the Studio data isn’t the founder’s 3,529. It’s the QA lead’s ramp: nothing for two weeks, then twenty, forty, ninety — then 277, 309, 188. A fifteen-fold personal ramp inside one quarter is biologically impossible for a typist. It isn’t a person learning to type faster. It’s a harness coming online — the coverage matrix, the gates, the agent workflows — and starting to pay compound interest.
Manual coding scales with effort. Fleet coding scales with the infrastructure you’ve built for the agents — and infrastructure compounds. That is the entire economics of the new theory in one sentence.
What a commit means now
Somewhere in this quarter, a commit quietly changed meaning. It used to be a proxy for an hour of typing. Now it is a decision someone was willing to stand behind — specified, reviewed, gated. When the marginal cost of producing code drops toward zero, everything scarce moves upstream: specification, verification, taste.
Which is why something funny happened to the metric itself. The moment commit counts became cheap to inflate, they had to become more rigorous to mean anything. The Studio numbers count distinct non-merge commits, dedupe rebase and cherry-pick copies, and exclude bot authors — not because anyone demanded an audit, but because volume without an honesty apparatus is now just noise.
The pretenders
Then there is the third cohort, the one the chart can’t show directly: teams that are AI-assisted the way a gym membership is fitness. The tell was never the tool subscription — it’s the shape of the process. Autocomplete in the editor at a one-pull-request-a-week cadence is the old workflow wearing a lanyard from an AI conference. Typing was maybe a fifth of the job, so accelerating it is invisible at chart scale.
That makes the pretense falsifiable: real adoption bends the curve somewhere. If nothing in the graph changed, nothing in the process did.
What adoption actually costs
Real adoption is expensive, which is exactly why it is rare. You have to restructure the work around the fact that agents are fast, tireless, and confidently wrong. Tests before code, because an agent lies with a straight face. Review gates as executable code, because human attention stopped scaling the day the fleet arrived. Documentation and memory as load-bearing infrastructure, because context is the fuel agents run on. An anti-forgery QA machine, because an agent will fake a green checkmark if faking is cheaper than passing.
A repository run this way grows organs a hand-coded repository never grows: skills folders, workflow gates, agent memory, deck generators, recount scripts. The organs are the proof. You can pretend to be AI-assisted on a conference panel. You cannot pretend your repo grew organs.
The inversion
Sit with that for a second. On an ordinary repository, CI bots sit near the top of the contributor leaderboard — github-actions has been committing for a decade. On the one repo where you would expect the machines to dominate the authorship, they sign almost nothing: a human stands behind every line. The question was never whether machines write code. The question is who takes editorial responsibility for what ships.
What survives
To be fair to the old way: volume isn’t value, and ten times the commits can be ten times the entropy. The craft virtues — coherence, taste, knowing why — did not become obsolete. They got promoted, from the line level to the system level. The old way got coherence for free, because one mind touched every line. The new way recovers it only by writing the mind down: product soul documents, design contracts, workflow rules. That, incidentally, is why tacit, undocumented seniority does not survive contact with a fleet — and why the people who thrive in the new mode are the ones who could always say what they wanted before they typed it.
In five years nobody will pretend to be AI-assisted. They’ll pretend they always were. And the teams whose charts never bent won’t have a tooling gap to close — they’ll have a theory to change.
Tools don’t bend curves. Theories do.
Companion piece to the Sirv AI Studio case study and build record.