Everyone has better models. Why do some teams fly while others don't?

Models got dramatically better over the past year. But they got better for everyone. In that time, our team went from 5.3 to 13.7 PRs per person per month, and I personally went from 4.8 to 51.3. Did you improve that much too? If not, here are a few things that work for us and might well help you as well.

Same model, different results

Claude, GPT, Gemini. We all have access to the same models. So when one team flies with a better model and another stays stuck in place, it's not the model. It's what the team built around it. Rules, tools, skills, CI.

To be honest right at the start: the models themselves did a big part of our speedup. I won't pretend we came up with everything ourselves. What I want to show is what we built around them and what I actually see in the numbers.

All of this is about the Keboola Connection repository. Five of us work on it in our team; other contributors come from other teams. I'm comparing the winter and spring at the turn of 2024 and 2025 with this summer and autumn.

Numbers first

Weekly PR counts in the repository from March to the end of October 2026.

Once again: part of this is purely better models. And most of our skills leave no trace, so take all the numbers below as a lower bound.

So what did we actually do?

Rules in one place

We used to have only CLAUDE.md. But we wanted to open the repo to other agents too, so in June 2025 we made AGENTS.md the single entry point for rules. CLAUDE.md now just imports it. And comments written by AI are signed. You can tell at a glance what a human wrote and what an agent wrote.

One entry point for humans and agents

In April 2026, Martin Zajíc, with whom I'm putting together our whole agentic setup, and I built ./bin/kbc. One CLI for everything. Running tests, static analysis, preparing the environment. Today it has 65 tasks, and 21 of our 33 skills refer to it. Plus kbc doctor, which checks whether your environment is in order.

Each of us uses it several times a day, and agents many times more. When the agent and the human use the same command, the agent doesn't have to guess how things are run here. And neither does the human :-)

Skills for repetitive work

In March 2025, Martin wrote a guide for migrating endpoints. This February, he turned it into the migrate-endpoint skill. In September, I followed up with the migrate-highway skill.

Then the migrations took off. We went from 3.7 migrated actions per month to 23.2. Of the 270 old Zend actions, 72 are left.

Sure, the timing overlaps with the arrival of better models. But the main benefit of the skill is elsewhere. With one simple call, the agent knows what to do. You don't have to explain anything, show it anything or look after it. It does the whole thing by itself.

The agent runs E2E tests by itself

The run-e2e-ci skill triggers the E2E Single Suite workflow in CI. It can run a whole suite or just a single test. In October alone, we ran it 238 times.

None of us has to deal with setting up a local environment anymore. And ours is really complicated because of testing Snowflake, BigQuery and other tricky cases. The author of a change just sets up CI, writes the test, and then anyone who changes the same code can run it.

I wrote about how we sped up those E2E tests in the first place in How I sped up E2E tests at Keboola.

Ready-for-review PRs without a human

For me, this is probably the most important piece. The babysit-pr skill watches over a PR. It handles failing CI and review comments. Agents talk to each other through GitHub comments and resolve most objections before a human even has to start paying attention.

So what comes out of the AI is a PR that's ready for review. Without any human involvement.

Seven to eight people use it, and in September and October the agent babysat over a hundred PRs a month this way.

A second review bot for when Copilot hits its limits

The ai-review label adds our own review bot to a PR. It runs on Gemini and gives us another review instead of Copilot when Copilot runs out of limits. The code is on GitHub as ai-codereviewer.

We've had it since March 2025, and in October alone others added it to PRs 183 times. Meanwhile, the median time to merge dropped from 49 h to 26 h, and that was even before the team started using Claude Code.

From Linear all the way to a PR ready for review

The ship-task skill takes a task from Linear and drives it all the way to a PR ready for human review. 53 of my PRs were created this way, with a median time to merge of 15.9 h. For PRs of the same size without it, it's 49.2 h.

An agent can always handle a well-prepared task in Linear or an RFC, so of course preparation matters a lot. But again, the main advantage of ship-task is that it makes our work easier. All it needs is a Linear issue ID or a markdown file with the task, and one simple prompt guides the agent through the whole journey. First, it analyzes the task again, because the code may have moved on since the task was written, and prepares a plan. That's the only point where it waits for my approval. Then it implements the task in an isolated worktree, does its own review, runs the tests including E2E, and opens a draft PR. Next, it starts babysit-pr in a subagent, which watches CI and handles review threads from bots and signed AI reviews. It never resolves human threads by itself. When everything is green, it flips the PR to ready-for-review and keeps watching it until a human approves it. You write one quick line, approve the plan, and a few dozen minutes later you come back to a green PR that has already gone through the agentic review rounds and is waiting for human review.

The agent cleans up technical debt

The PHPStan baseline. That file where you hide the errors you "don't have time for right now". We had 2,467 errors in it. Today there are 1,081. They're being cleaned up by a skill that picks an error, fixes it and verifies the fix.

This is exactly the kind of work nobody ever has time for, and the agent doesn't mind.

Open doors for other agents

The team mainly uses Claude Code. But we didn't want to lock ourselves into one agent. So we moved 31 skills to .agents/skills, which means they also work with Codex and Copilot. Right after that, the first review comments from Codex showed up on PRs.

The main benefit is elsewhere, though. Now people from other teams in the company can come with their own agents, and their PRs can mostly be merged without major changes. And we have the door open to other agents and experiments.

Where I'd start

The overall PR volume grew mainly thanks to the models. The setup doesn't work miracles by itself. But without it, we practically couldn't handle that many PRs at all.

If I were building it again, I'd go in this order:

1. Rules in one place (AGENTS.md).
2. One CLI entry point for humans and agents.
3. Skills for repetitive work.
4. CI the agent can run by itself.
5. An agent that watches the PR until it's ready for review.
6. Independence from a single agent.

You get a better model for free. Everything around it, you have to build yourself.