Entering the Agentocene: A Statistical Investigation of AI-Era Coding

Table of Contents

TL;DR

A Lesson from Epidemiology

A Short History of Not Writing Code

Naming the Epoch: The Agentocene

The Question: Is It Measurable?

Method: How I Analyzed 5,009 Repositories

Results

Finding 1: AI Tools Went from Unmentioned to Unmissable

Finding 2: An Involuntary Signal Says the Same Thing

Finding 3: Does It Mean More Code? Not Provably, Not Yet

Implementation Aspects

Limitations

What This Means

TL;DR#

This started as a search for KPI differences from AI adoption. That led to a more basic question first: can a shift like this be proven statistically at all?

Software keeps handing more work to the machine: compilers, libraries, autocomplete. AI is the next step, and this time it shows up in the data, not just in opinions.

I mined 5,009 git repositories (Rust, Python, JavaScript, TypeScript, commit history from 2019 through mid-2026) and tracked 10,812 individual developers to look for a measurable trace of that shift.

It’s there, from two signals that agree with each other independently. Literal AI-tool mentions in commit messages went from essentially zero to 1 in 8 commits by July 2026. A much harder-to-fake signal, a sudden, lasting jump in how long people’s commit messages get, shows the same accelerating curve for 15% of the developers with enough history to check.

Whether this is already producing more code, not just different-looking commits, is a separate and harder question. My data doesn’t answer it cleanly yet, and I say so plainly further down.

This new era is already being called the Agentocene: agents do the work, we no longer code by hand.

A Lesson from Epidemiology#

In June 2026, Europe was hit by a heat wave unlike any on record. The question everyone asked: how many people died because of it?

That’s where epidemiology runs into a familiar wall. For any single death, it’s nearly impossible to prove that heat was the cause. The death certificate says heart failure, not 42 degrees.

The proof doesn’t need single cases, though. Statistics answers the question with excess mortality: you compare the observed number of deaths against the number you’d expect from previous years. When mortality climbs far above that baseline, the heat has left its mark, no individual attribution required.

EuroMOMO, the European mortality monitoring network, publishes exactly this comparison every week: observed deaths against an expected baseline and its normal range, pooled across 25 countries. The gap between the line and the band is the excess, no autopsy needed for any single death in it.

I used the same principle to test for the Agentocene, the era in which AI agents write our code. Look at a single commit and you can rarely prove an AI produced it. Commits carry no reliable label, and AI-text detectors don’t work reliably on prose, let alone on code. But if AI agents really changed how software gets written, that change has to surface as a structural deviation in the aggregate data of many repositories, the same way a heat wave surfaces in death counts, not in any one obituary. This post is about finding that deviation.

A Short History of Not Writing Code#

Software has always been a story of programmers handing work to machines. In the early decades, writing directly in assembly was the only option, and every instruction, every register, was a manual decision made by a person. Adding two numbers and printing the result took real work:

; x86 Linux syscalls: compute 5 + 7 and print the result section .data a dd 5 b dd 7 buffer db 10 dup(0)

section .text global _start _start: mov eax, [a] add eax, [b] ; eax = 12

mov ecx, buffer + 9 ; convert eax to ASCII, back to front mov ebx, 10 .convert: xor edx, edx div ebx add edx, '0' mov [ecx], dl dec ecx test eax, eax jnz .convert inc ecx

mov edx, buffer + 10 - ecx mov eax, 4 ; sys_write mov ebx, 1 ; stdout int 0x80

mov eax, 1 ; sys_exit int 0x80

Twenty-some lines, and I still glossed over register allocation and the calling convention. Here’s the same thing after a few decades of delegation:

print(5 + 7)

Then came compilers, and plenty of programmers hated the idea. Trusting a machine to decide which instructions to emit felt like giving up precision, maybe giving up craft altogether.

It’s worth remembering how big that jump actually was, and it happened to come up again very recently. In May 2026, at the Open Source Summit in Minneapolis, Linus Torvalds made almost exactly this point while pushing back on claims that “99% of our code is AI-written” now circulating in parts of the industry. As LWN reported, his comparison was blunt: compilers increased programmer productivity by something like a factor of a thousand. AI, in his estimate, adds maybe another factor of ten on top of that. He wasn’t dismissing AI: he pointed out that Linux kernel submissions had climbed roughly 20% over the prior six months, and he credited better AI tooling with lowering the barrier to writing a decent kernel patch. His point was about scale, not existence. Compilers were the bigger revolution, and nobody today calls a compiler a co-author.

After compilers came high-level languages and garbage collection, another vote to trade raw machine efficiency for less time spent on bookkeeping a human doesn’t need to do by hand. Then package ecosystems arrived, and at some point most of us stopped writing what we could just npm install or pip install instead. Then IDEs, autocompletion, static analysis, linters that flag a bug before you’ve finished typing the line.

Every one of these steps had its critics at the time. Real programmers don’t need a debugger. Real programmers write their own hash table. Each delegation looked, in the moment, like it might be the one that finally goes too far. None of them did. Programmers kept programming, just at a different layer, further from the machine and closer to the problem.

AI-assisted coding doesn’t slot neatly into this stack as just the next rung, though. Every earlier delegation replaced one specific layer: a compiler replaced instruction selection, a garbage collector replaced memory bookkeeping, a package manager replaced rewriting what already exists. Each tool did its one job and left the rest of the stack alone. AI can work at any of those layers, or all of them at once. Ask it to write assembly and it will. Ask it to skip straight to machine code and it can do that too, badly and wastefully, but it can. Nothing before it could collapse the entire stack like that.

That’s why I’d call this the biggest change in how software gets built since programming began, bigger than compilers, bigger than open source. The clearest evidence isn’t in git history at all. It’s in who is shipping software now: people who never learned to program are already building working, sometimes large, software projects end to end. The statistics in this post are one way to measure the shift. That’s another, and it’s already visible.

Naming the Epoch: The Agentocene#

Geologists have a formal process for declaring a new epoch. They look for a golden spike, officially a Global Boundary Stratotype Section and Point: a single, physical, measurable marker in the rock that lets you point at a layer and say, here, this is where the old epoch ends. The proposed marker for the Anthropocene, the epoch defined by human impact on the planet, is a thin band of plutonium isotopes from mid-20th-century nuclear tests, deposited into sediment worldwide within the span of a few years.

I want to borrow that idea for software, not just the name. If AI-assisted coding really marks a new era, the same logic should apply: there ought to be a golden spike somewhere in the historical record of how software gets built. Not an opinion, not a vibe. A measurable deviation in the sediment.

Our sediment is git history: millions of commits, timestamped, diffed, attributable down to the month. If the Agentocene, the era where agents do the writing and we do the deciding, has actually begun, it has to leave a trace in that record the same way plutonium left a trace in ocean mud. This post is my attempt to find that trace.

I drew my own core sample to check. The strip below is the AI-tool mention rate from the dataset described further down, plotted like a drilled core, oldest at the bottom, most recent at the top, color-coded on a log scale so the near-zero years read as one uniform layer. The color visibly changes in March 2023, the month GPT-4 shipped, and never goes back.

The Question: Is It Measurable?#

Ask around and everyone has an opinion. Developers say AI either makes them dramatically faster or mostly gets in the way, sometimes in the same conversation. Surveys ask people how much they think AI helped, which mostly measures how people feel about AI, not what actually changed in the code they shipped.

I wanted different evidence: not what people say about AI, but what shows up, unprompted, in the repositories they actually work in. That means going to the source, git history at scale, and looking for a pattern that couldn’t easily exist by coincidence.

Method: How I Analyzed 5,009 Repositories#

The tempting design is simple: average lines of code per week before ChatGPT, average it again after, compare. It doesn’t survive scrutiny. There’s no control group, since essentially every developer got exposed to AI tools around the same time, so any coincident trend, more remote work, better tooling in general, repos simply growing older, gets tangled up with “AI”. Adoption itself is unobservable at scale: trailers like Co-Authored-By: Claude get stripped by squashing, rebasing, pre-commit hooks, or plain opt-out, so their absence tells you nothing. Lines of code is a mediocre productivity metric on its own, since more lines can mean bloat or generated boilerplate just as easily as useful work. And repos still alive in 2026 are not a random sample of repos that existed in 2020; the dead ones already dropped out of the picture.

So the design I actually used looks different:

Dataset: 5,009 repositories across four languages, Rust, Python, JavaScript, and TypeScript, mixing curated lists of well-known, long-lived projects with a systematic GitHub search, every repo required to show real, recent commit activity to qualify, no dead projects included

Time range: full commit history from January 2019 through mid-2026, 91 months, anchored on November 2022, the month ChatGPT shipped, as the dividing line between “before” and “after”

Continuity filter: 2,084 of the 5,009 repositories had commit history clean enough, no long gaps, activity on both sides of the anchor, to support a proper before/after comparison. The rest were either too young, had gone dormant, or had gaps in the record, and were tracked separately rather than silently dropped

Unit of analysis: individual developers, not whole repositories. A repo’s average output can shift just because the team got bigger or smaller, which has nothing to do with AI. An individual’s own trend over time can’t lie to you the same way. Across the 2,084 included repositories, that’s 10,812 developer histories

Signals, since disclosure can’t be trusted, a battery of indirect measurements instead of one “AI used here” label:

each developer’s own code-churn trend, extrapolated forward and compared against what actually happened afterward (an excess-churn design, borrowed from the same logic as excess mortality)

a calibrated model estimating each developer’s probability of AI use, trained on the rare cases where a genuine, if noisy, label exists (the chart below shows the resulting distribution)

two signals that don’t rely on anyone disclosing anything at all: literal AI-tool mentions

[truncated for AI cost control]