Stop counting pull requests now that agents open them
Pull requests as a performance metric measure nothing once agents open them. Count cards a person asked for that the team merged, then check the work held.
Pull requests as a performance metric measure nothing once agents open them. Commit count and tickets closed measure nothing either. An agent will split the work as small as you like, and people were already doing that by hand. Those are the developer productivity metrics, and the engineering metrics for AI coding agents, that I would stop using.
The count was already a game
On r/ExperiencedDevs, N of PRs as an ultimate performance metric was removed by a moderator. I am quoting comments. I am not quoting the post.
u/WhiteXHysteria wrote:
Had a consultant tell us they were doing X% more commits now that they were using their properties agent this. I asked a few sessions later if they found the agent does more commits for a piece of work than a human developer. And they happily told us that they explicitly tell it to make much smaller commits than any human would so it's easy to digest.
The percentage is the consultant's. I am not repeating it as a result. The useful part is the instruction. Tell the agent to cut smaller commits than a person would. The count goes up. The work is the same size.
u/Maxpowerfreak wrote:
With AI nowadays, it's very easy to adjust to these types of metric-based goals. Be they tickets closed or PRs created.
And:
Tickets closed? No problem, I'll split this 5 pointer into three 2-pointers and even get some extra story points completed out on the board.
Yup. Tickets closed and pull requests created are the same kind of target. Split the work until the number looks right. That is what counting the artifacts gets you.
u/throwaway_0x90 wrote:
I could split a Java version of "HelloWorld" into 99 PRs if I wanted.
And:
But you know what's really hard to game? impact.
I don't have a formula for impact, and I am not going to invent one. What I will count is narrower. A card a person asked for, that a person reviewed and merged, and that was still in the tree later.
u/theKetoBear wrote:
Track the project not the work would be my perspective.
Yup, if the alternative is counting artifacts. A deadline that slipped is a fact about the project. A pile of pull requests is not.
Review is the bottleneck
Code review is now the bottleneck. I'm experimenting with diff visualization tools to help me judge PRs faster and ship quality software.
Mikk Martin posted that on November 8. Code review is now the bottleneck. He is trying diff visualization so he can judge pull requests faster. The post has a 23 second video. I have not watched it, and I have not used the tool. The first sentence is the one I agree with. The queue is the constraint. How many pull requests got opened is not.
Very cool, but maybe in about 12 months from now, we won't do code review anymore.
Things left for human to review is product behavior / UI (taste)
Tony Dinh is quoting that post. "Very cool, but maybe in about 12 months from now, we won't do code review anymore." Then: "Things left for human to review is product behavior / UI (taste)."
I don't buy the second part. Taste is real. It is not the only thing left. Someone still has to say the change did what was asked, and that it belongs on the branch. Checking the card before the diff is the split I wrote up in AI code review vs verification: check the card, then the diff.
Just stop reviewing so many PRs. I tried so many different concepts for this over the last 18 months.
Now I don鈥檛 need a human review on most PRs.
- setup architecture linters not skills
- setup test boundries and zones so you don鈥檛 end up with thousands of pointless tests.
- setup shared vocabulary
- move ci to local so you are not blocked by GitHub action minutes.
- setup code review agents locally before or and then security & performance pr review automation.
Done.
If you have the right framework you can just let them run now.
JJ Eaton's reply is the counterpoint I do use. "Just stop reviewing so many PRs. I tried so many different concepts for this over the last 18 months." Then: "Now I don't need a human review on most PRs." The rest of the post is the mechanical stuff. Architecture linters, test zones, a shared vocabulary, CI on the machine instead of waiting on GitHub, a local review pass, then security and performance. Automate that. I don't want a person re-reading a lint finding.
I would not take the last step he takes. On a team, a named person still accepts the work, and that person merges. A typo or a dependency bump can be a glance once the checks are green. Billing, auth, migrations, and CI do not get that glance. How I sort the queue is in How to review AI agent pull requests without drowning. Who the person is, before the run starts, is in Name a human owner before the agents open pull requests.
I ship with coding agents every day. Pair on the change, open the PR, merge, deploy.
At merge time, every one of those PRs looks the same: CI green, approved. Some still get reverted a week later. When that happens, I can't answer the obvious questions. Which session wrote it? Which model? Which version of my prompt? What did the agent skip?
Git knows what changed. The agent knows what it did. Nothing connects the two.
Agent Analytics now tracks coding agents too.
Claude Code, Codex, Cursor, Copilot, Gemini CLI, goose and more, so you can:
- See the work. Open any session in any harness, down to every message and tool call.
- Score it. Built-in signals and topics run on every session, plus your own evals, like "Did it keep every constraint I gave it?"
- Tie it to outcomes. Each agent commit is linked to the session that wrote it, then followed to merged, deployed or reverted.
- Pull the right lever. Cost per change that held, split by model and topic, by how the agent ran, and by setup version.
Green CI isn't the finish line. Ship fast. Know what held.
Vinay Goel ships with coding agents. Two sentences of his are the point, and the rest of the post is a tool he has built. I have not used it, and I am not describing it. "At merge time, every one of those PRs looks the same: CI green, approved. Some still get reverted a week later." And: "Green CI isn't the finish line." A merge that comes back out a week later was not work that held. It was a pull request that looked finished.
Faros AI measured a cousin of that, and I am not going to pretend it is the same number. In the AI Engineering Report 2026 they define code churn as the ratio of lines deleted to lines added for merged code in a quarter, and they write that it "has increased 861% under high AI adoption." The same report says the throughput numbers "measure what was shipped. They do not tell you what survived." It also says the research cannot tell rework apart from a large refactor, or from people finally cleaning code up. tbh I am not calling 861% a revert rate. I don't have their data. The sentence I keep is shipped versus survived.
What I would count

Pull requests opened, commits, tickets closed. The agent can mint these, and a person who wants the number can too. Work accepted is the other column. A card a person asked for. A person reviewed it and merged it. You looked later, and it was still there.
That last look is a check you do. It is not a dashboard I can point at. Green CI does not do it. An approval does not do it. Both can be true on a pull request that gets reverted, which is Vinay's point.
When someone asks what shipped, say what was accepted. Don't answer with how many pull requests the agents opened. The note I paste for that is in A status update template for agents: BLUF, then SBAR.
What Kahoona can show
I built Kahoona, so weigh this part.
It is one board. You put the work on a card and hand it to the agent, by assigning the card or by writing @agent. The run stores the person who asked. Kahoona's agent opens a GitHub pull request and stops. If the checks you configured still fail after two fixes, the pull request stays a draft, the card says Needs you, and it goes back to that person. A run that gets through moves the card to review and marks the pull request ready. A person merges. Agents never merge, and they never deploy. There is no merge tool.
On the whiteboard, an agent can propose a build. That proposal sits until a person sends it. It does not create the card, and it does not start the run.
A session on a read-write key is a different door. MCP can call create_task, update_task, move_task, and comment_on_task as the person who owns the key. The app will not stop that session from minting cards, or from assigning one to the agent. If you count cards created, the agent can still split the work. Don't. That limit is a rule you keep. The limit the app actually enforces is the merge.
GitHub moves the card. A draft pull request moves it to in progress. A pull request that is ready moves it to in review. A merge moves it to Done when the title or body uses a closing word, such as fixes WEB-14, and the merge lands on the branch the project watches. The pull request Kahoona opens ends with that closing line. A mention with no closing word links the card and does not finish it. Closing the pull request without merging does not move the card. It suggests moving the card back, and a person applies that.
A commit whose message starts with Revert " does not mark a card done. A card that is already Done stays Done. Kahoona does not see the revert and take the card back out. "Not reverted" is still your check. I would not call the Done column proof that the work held.

The standup is the closest list, and it is not a score. The switch says Since yesterday and This week. Since yesterday is the previous working day, so Monday looks back to Friday. This week starts on Monday, in your timezone. Shipped is cards in Done in that window, under the person who owns the card. A linked pull request that updated to merged in the window can mark the time. The line shows the pull request number and merged. It does not count pull requests that were only opened. A card with nobody on it does not show up there. The agent user is named Agent, and it is not a member, so a card still assigned to Agent does not get a standup column. When the run finishes, the card goes back to the person who asked, and that is the name on the wall.
Stuck is separate. An unfinished blocker, failing checks on an open pull request, or a card waiting on a client. The line under the switch says it is written from your repo and board. Copy as update copies the paragraph. It is a status. It is not a leaderboard. Dragging a card to Done counts for that window, even when no pull request merged. A pull request that is only ready, sitting in review, is not Shipped.
The Friday update is the weekly timeline on the GitHub tab. Weeks start on Monday, UTC. Each pull request is its own theme. Loose commits, checks, and notes sit in those three buckets. The number on a theme is how many GitHub events it has. An opened pull request sits next to a merged one. The log keeps itself current from GitHub. It is not a performance metric, and it does not know that the merge was reverted the week after.
The Oversight dashboard counts cards in Done against all the cards, plus blockers and anything overdue. That is progress on the board. Dragging a card to Done moves the number. It is not work that held, and it is not a count of pull requests.
If the questions are already visible in Linear, stay there. I compared the boards in Kahoona vs Linear. If the company already lives in Jira, same answer, in Kahoona vs Jira.
Kahoona is the wrong tool when you want a dashboard of pull requests opened, or when you want the agent to merge, or when you want a number that means the work held. I don't have that number. The board shows the card, the pull request, and Done after a person merges. You still look at what got reverted.
Kahoona is free for one person. On a team the first chair stays free and each extra chair is $5 a month, so five people pay $20 and ten pay $45. No card to start. It is a web app.
The number I use is the work a person accepted, after I have checked it stayed.