The Commit Count That Went 2.3 Times Up

At almost 1am we were reading four years of our own git history over SSH from a phone. A conversation about revenue had turned into a question we couldn’t answer: what did AI actually do to our team?

Everyone we talk to has a story about AI making them faster. The stories are all vibes, and ours was too until we pulled the actual numbers.

Context: we run a live SaaS platform. The team is a support dev, a designer, a reviewer, and a developer. The AI coding agent arrived about six months ago. Here is what the record says it did.

One loop over git

No survey, no self-report:

# commits per author per year, merges excluded
for y in 2023 2024 2025 2026; do
  echo "== $y =="
  git log --no-merges --since="$y-01-01" --until="$y-12-31" \
    --format='%an' | sort | uniq -c | sort -rn
done

What it printed, by author:

The developer’s 1,105 commits in six months annualize to about 2,200, roughly 2.3 times the earlier rate. The support dev sat around 300 a year for three straight years and is now pacing about 670, the same 2.3x. The designer had seven commits to their name before this year and has shipped 106 in six months. They are a developer now.

The reviewer is the exception. Their commits are flat to down, but their review comments tripled year over year and concentrated: about five per issue they touch now, versus two a couple years back. They barely use the agent themselves. More on that below.

Tickets resolved as a team: we peaked near 1,470 a year in 2019, cratered to about 510 in 2022 during our biggest product bet, and are now pacing about 1,270. That is back near peak, at roughly half the historic contractor cost.

Two queues disappeared

The multipliers are the headline. The structural change underneath them is what reshaped the company: work stopped queuing on people.

Until recently this team had two serialization points. Anything heavy came back through code review. Anything visual waited on the designer. Those two queues were the shape of the company, and every process we had was built around them.

Six months in, both queues are gone.

The support dev’s backlog used to be “things waiting for review.” Once comfortable with the agent, one of the first things they did was clear that backlog themselves. When their tasks need design thinking, they no longer wait for the designer either. They prototype with the agent and the designer reviews a working thing instead of a request.

The designer’s change is bigger. Our old flow was hours of scope meetings, then one developer coding alone, then iteration. Now the designer has ideas the rest of us don’t fully agree with or even understand, and instead of spending meetings convincing us, they explain them to the agent and build them. One of those, a feature that would have been called a multi-month project, went from created to live in about eight weeks with exactly one commit from the developer out of thirty. Another, a concept we were lukewarm on, is nearly finished without anyone needing to be sold on it first.

And the styling work that used to eat evenings, the endless pixel tweaks that were the worst use of those hours and the best use of the designer’s eye, now goes to the designer. A whole category of time, returned.

The teammate who didn’t adopt

The reviewer uses the agent the least of anyone, and became more valuable, not less.

When everyone else’s volume doubles, the scarce resource stops being production and becomes judgment. Their deep review threads are the quality gate that lets the rest of us run this fast. If we had measured adoption by who uses the AI most, we would have scored our most important adaptation as a failure.

Every gain in a different currency

Our sense of it was just “we’re faster.” The data said something more specific. Every person’s gain landed in a different currency: volume for the developer and the support dev, capability for the designer, depth for the reviewer. Each of those needs a different thing from us now, and we couldn’t see any of it until we queried it.

Two caveats, because the numbers tempt overclaiming. Commit counts measure activity. They say nothing about size or quality, and AI-era commits trend smaller and more frequent. Some of the activity under the developer’s name is agent sessions committing under that name. The direction and the multiples survive both. The precision doesn’t.

Six months ago we would have told you AI made us faster. That undersold it. It reorganized the company, and we only found out by reading the logs.

If you want to know what AI did to your team, query your own commit and ticket history and look at each role separately. Don’t score adoption by who uses the agent most, and read commit counts as a direction with no claim to precision.