Same team, 2.8x the merged PRs: what AI changed at Lagarsoft

Same team, 2.8x the merged PRs in a year. 25 months of real data on what AI changed in our developer velocity, what it didn't, and where a PR count lies.

By Pablo Gancharov

engineering · strategy

Generative line-art thumbnail: stacked horizontal lines lifting into broad diagonal folds toward the upper right, evoking steady output that steps up in stages

Did AI make our team ship more? Yes, and we have the numbers. Same team the whole way through. In October 2026 we merged 401 pull requests, 2.8x October 2025. And 2026 through October (2,231 PRs) is already nearly double all of 2025 (1,135). That’s the clearest developer velocity number we have, and we have 25 months of it.

Some of that curve is AI. Some of it is a team finding its stride. Here’s how we tell the two apart, what we think moved the line, and where we wouldn’t trust it.

Merged pull requests per month, October 2024 to October 2026Bar chart. Ramp-up from 16 to 36 PRs a month in late 2024. 2025 averages about 95 a month, ranging from 63 to 143. January to August 2026 averages about 190. September and October 2026 average about 356, peaking at 401 in October 2026.0100200300400October 2024: 16 merged PRsNovember 2024: 26 merged PRsDecember 2024: 36 merged PRsJanuary 2025: 84 merged PRsFebruary 2025: 98 merged PRsMarch 2025: 78 merged PRsApril 2025: 63 merged PRsMay 2025: 68 merged PRsJune 2025: 100 merged PRsJuly 2025: 92 merged PRsAugust 2025: 97 merged PRsSeptember 2025: 106 merged PRsOctober 2025: 143 merged PRsNovember 2025: 105 merged PRsDecember 2025: 101 merged PRsJanuary 2026: 175 merged PRsFebruary 2026: 173 merged PRsMarch 2026: 215 merged PRsApril 2026: 182 merged PRsMay 2026: 164 merged PRsJune 2026: 197 merged PRsJuly 2026: 197 merged PRsAugust 2026: 215 merged PRsSeptember 2026: 312 merged PRsOctober 2026: 401 merged PRsOct2024Jan2025AprJulOctJan2026AprJulOct2025: about 95Jan to Aug 2026: about 190Sep to Oct 2026: about 356143401Ramp-upMerged pull requests per month, October 2024 to October 2026Bar chart. Ramp-up from 16 to 36 PRs a month in late 2024. 2025 averages about 95 a month, ranging from 63 to 143. January to August 2026 averages about 190. September and October 2026 average about 356, peaking at 401 in October 2026.0100200300400October 2024: 16 merged PRsNovember 2024: 26 merged PRsDecember 2024: 36 merged PRsJanuary 2025: 84 merged PRsFebruary 2025: 98 merged PRsMarch 2025: 78 merged PRsApril 2025: 63 merged PRsMay 2025: 68 merged PRsJune 2025: 100 merged PRsJuly 2025: 92 merged PRsAugust 2025: 97 merged PRsSeptember 2025: 106 merged PRsOctober 2025: 143 merged PRsNovember 2025: 105 merged PRsDecember 2025: 101 merged PRsJanuary 2026: 175 merged PRsFebruary 2026: 173 merged PRsMarch 2026: 215 merged PRsApril 2026: 182 merged PRsMay 2026: 164 merged PRsJune 2026: 197 merged PRsJuly 2026: 197 merged PRsAugust 2026: 215 merged PRsSeptember 2026: 312 merged PRsOctober 2026: 401 merged PRsOct2024Jan2025Jan2026avg 95avg 190avg 356143401
Merged pull requests per month, same team, bot PRs excluded. Gray bars are the ramp-up months; horizontal lines mark each period's average.
Show the monthly numbers
MonthMerged PRs
October 202416
November 202426
December 202436
January 202584
February 202598
March 202578
April 202563
May 202568
June 2025100
July 202592
August 202597
September 2025106
October 2025143
November 2025105
December 2025101
January 2026175
February 2026173
March 2026215
April 2026182
May 2026164
June 2026197
July 2026197
August 2026215
September 2026312
October 2026401

What we counted

Every pull request the team merged from October 2024 to October 2026, per calendar month, across the web, API, backend and mobile repos it works in. Bot PRs (dependency bumps and the like) are excluded. Everything here is custom software in production with paying users.

That context matters for reading the chart. When real users depend on the software, a quiet bug costs more than a slow week. So “ship more” was only ever useful to us if it came with “and it still works.”

Which part of the curve is AI?

Start with the part that isn’t. October to December 2024 was ramp-up: new repos, first features, people learning the domain. Climbing from 16 merged PRs in October to 36 in December is what any team’s first quarter on new work looks like. We give AI no credit for it.

After that, the monthly numbers settle into 3 levels:

PeriodMerged PRs per month (average)
2025about 95
January to August 2026about 190
September to October 2026about 356

The line moves in steps. 2025 bounces between 63 and 143 with no real trend. Then January 2026 jumps and holds for 8 months. Then September jumps again.

A slow climb would be hard to attribute to anything. Steps are easier, because you can look at what changed the month before each one.

And the team was the same size through all 3 levels. That’s the first thing we’d check on anyone else’s chart: no one was hired to make the bars go up, and the headcount in October 2024 matches October 2026.

One more honest caveat: the gain isn’t spread evenly. Our most active engineer merged about 21 PRs a month in 2025 and 157 a month in September and October 2026, including 190 of October’s 401. Take that one person out and the rest of the team still went from about 74 PRs a month in 2025 to about 133 (1.8x) in January to August 2026 and about 200 (2.7x) in September and October. So the January step is broad. The September step leans hard on 1 engineer.

Is a merged PR a fair way to measure developer velocity?

On its own, it’s a weak one. PR count is easy to inflate. Split one change into 5 PRs and you’ve “quintupled” your output. A team that knows it’s being measured on PRs will start opening smaller ones, and the chart goes up while nothing real changes.

We still think it’s a decent signal for us, for 2 reasons:

  • Every PR we counted passed human review and CI before merge. Bot PRs (dependency bumps and the like) are excluded. Each bar counts changes a person wrote, another person approved, and the pipeline let through.
  • The team wasn’t working toward this number. We pulled the data after the fact. No one had a PR target.

So we checked whether the PRs got smaller. They got bigger. In 2025 the median merged PR changed 109 lines across 4 files. From January to August 2026 it was 204 lines across 5. In September and October 2026, 743 lines across 13 files. The count went up 3.7x and the typical PR got about 7x larger at the same time, which is the opposite of slicing the same work thinner.

Lines changed is a bad metric on its own too (lockfiles, generated code, and AI-written boilerplate all inflate it), so we only use it to rule out the slicing objection. It does raise a different worry, which we’ll get to: bigger PRs are harder to review.

What changed day to day

The short version: writing the change stopped being the slow part.

When execution gets cheap, the work piles up somewhere else. For us it piled up at the seams between writing code and shipping it. PRs sat waiting because reviewers didn’t know it was their turn, so one of our engineers built a review notifier that tracks exactly that. CI became a budget instead of a background chore: at one point we’d burned 2,701 of our 3,000 monthly GitHub Actions minutes with 23 days still left in the cycle.

You can see the pressure in the data. In 2025 the median PR was open for about 2.6 hours before it merged. In September and October 2026 it was about 14 hours. PRs got bigger, there were far more of them, and review is where they waited.

None of that shows up as a bar on the chart. But without the tooling, the January step would’ve been a pile of open PRs instead of merged ones.

What had to be true for the extra PRs to be safe

More PRs on a codebase with no tests just means more bugs, delivered faster. We made this point when we wrote that vibe coding is cheap and winning still isn’t: generating code was never the hard part to begin with.

What held were the boring things. A human reviews every change. CI runs on every PR, and nothing merges red. The most critical logic has its own tests, because that’s where a quiet mistake costs the most.

That’s what made the speed usable. The AI made the changes cheaper to write. The review, the pipeline, and the tests are why we were comfortable merging 401 of them in a month.

How to measure your own team’s development velocity

If you’re trying to work out whether AI is moving your engineering velocity, here’s what we’d check first:

  • Get the baseline before you change anything. We could only draw this chart because we had more than a year of history from before the jump. Pull it now, even if it’s ugly.
  • Look for steps, and name what caused each one. A smooth curve tells you almost nothing.
  • Divide by headcount, then look at who’s driving it. If the team doubled and PRs doubled, AI didn’t do it. And if one person accounts for most of the gain, what you’ve found is that person’s workflow. Find out what they do differently and spread it.
  • Check PR size next to PR count. If the count rises while PRs shrink, you may just be slicing the same work thinner.
  • Watch the queue next to the one you sped up. If PRs open faster than they merge, the bottleneck just moved to review. We wrote about how agile’s rituals shift when that happens.
  • Count what merged. Lines of AI-written code is a vanity metric. A reviewed, merged, deployed change is closer to something a user feels.

If you’re looking at your own numbers and they don’t look like this, or they do and you’re not sure the quality held, we’re happy to compare notes.

Quick answers

Does AI increase developer velocity? On our team, merged PRs per month roughly doubled from 2025 to the first 8 months of 2026, and nearly doubled again in September and October 2026, with the same team size throughout. The gains held because review, CI and tests stayed in place.

Why is measuring velocity by volume wrong? Because volume is easy to inflate. Splitting one change into several PRs raises the count without shipping anything more. Volume only means something next to PR size, review, and headcount.

Is PR count a good measure of software development velocity? It’s a weak metric alone and a useful one with guardrails: exclude bot PRs, keep human review on every change, check that PR size didn’t shrink, and normalize by headcount.

Where does AI help most in software delivery? In our experience, writing the change. The constraint then moves to review and CI, so that’s where the next round of work goes.

Tell us what you're building.