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

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.
Show the monthly numbers
| Month | Merged PRs |
|---|---|
| October 2024 | 16 |
| November 2024 | 26 |
| December 2024 | 36 |
| January 2025 | 84 |
| February 2025 | 98 |
| March 2025 | 78 |
| April 2025 | 63 |
| May 2025 | 68 |
| June 2025 | 100 |
| July 2025 | 92 |
| August 2025 | 97 |
| September 2025 | 106 |
| October 2025 | 143 |
| November 2025 | 105 |
| December 2025 | 101 |
| January 2026 | 175 |
| February 2026 | 173 |
| March 2026 | 215 |
| April 2026 | 182 |
| May 2026 | 164 |
| June 2026 | 197 |
| July 2026 | 197 |
| August 2026 | 215 |
| September 2026 | 312 |
| October 2026 | 401 |
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:
| Period | Merged PRs per month (average) |
|---|---|
| 2025 | about 95 |
| January to August 2026 | about 190 |
| September to October 2026 | about 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.


