{"id":3476,"date":"2026-07-22T11:58:52","date_gmt":"2026-07-22T11:58:52","guid":{"rendered":"https:\/\/justfineinfotech.com\/small-teams-are-the-heaviest-users-of-ai-coding-agents-help-net-security\/"},"modified":"2026-07-22T11:58:53","modified_gmt":"2026-07-22T11:58:53","slug":"small-teams-are-the-heaviest-users-of-ai-coding-agents-help-net-security","status":"publish","type":"post","link":"https:\/\/justfineinfotech.com\/fr\/small-teams-are-the-heaviest-users-of-ai-coding-agents-help-net-security\/","title":{"rendered":"Small teams are the heaviest users of AI coding agents – Help Net Security"},"content":{"rendered":"

Small teams are the heaviest users of AI coding agents<\/p>\n

The pull request arrives with the tests already run and the description already written, the work of an agent that handled the whole thing on its own. Somebody still has to read it. On GitHub that somebody is usually one developer sitting alone with the diff, and the rest of the project never sees the code<\/p>\n

Maliha Noushin Raida and Daqing Hou at Rochester Institute of Technology sorted 25,264 agentic pull requests by who reviewed them and who committed to them. The repositories all carry at least 100 stars, the agents are the ones most developers have already met, GitHub Copilot and OpenAI Codex and Claude Code, and the window runs from May through July 2025<\/p>\n

One developer does the reviewing and the fixing<\/h3>\n

Most agentic pull requests pass through the hands of a single developer, who reads the agent\u2019s code, fixes what needs fixing, and merges it. The setup covers 78.9% of the pull requests in the dataset<\/p>\n

It plays out the way plenty of maintainers already work. Prompt the agent, wait for the pull request, open it, edit a few lines, ship it. Count the cases where someone reviews the agent\u2019s work and leaves it as is, and one-person oversight covers close to nine in ten<\/p>\n

Group review stays rare at every size of project. Small teams lean hardest on the solo routine, and bigger teams spread the work around more often without displacing it<\/p>\n

Most repos run one or two a quarter<\/h3>\n

The median repository opened one or two agentic pull requests in three months. That is the whole quarter. For most projects on GitHub the agent turns up now and then and goes quiet again, and only a sliver of contributors ever touches its work<\/p>\n

The heavy usage belongs to the tiny teams. Repositories with one to five contributors averaged 50.2 agentic pull requests apiece, many times what medium and large teams managed, on the strength of a few outliers running agents hard. Line the small projects up and the one in the middle looks like everybody else<\/p>\n

More output, same one reviewer<\/h3>\n

Raida went back to the small teams that cleared 30 agentic pull requests in the window and checked who was reviewing them<\/p>\n

\u201cEven among the most active small repositories (i.e., small teams with more than 30 agentic PRs), the majority of agentic PRs continued to follow a single-reviewer workflow,\u201d Raida told Help Net Security. \u201cThis suggests that increased agentic activity did not necessarily lead to more distributed review practices.\u201d<\/p>\n

The agent scales up. The review desk stays one person wide<\/p>\n

Review is the ceiling<\/h3>\n

The catch is review. Code review already eats a large slice of the workweek for most developers, and every agent pull request still has to be read, tested, and judged worth merging. That work sits with a human, and there are only so many hours in it<\/p>\n

The limit shows up in the numbers. Twenty-five projects in the sample generated agent pull requests at the clip a working developer ships code, going by a Worklytics benchmark of professional output. Everybody else came in under it<\/p>\n

Solo and group review end the same way<\/h3>\n

Pull requests handled by one person get merged at close to the same rate as those handled by several<\/p>\n

\u201cThe merge rate (i.e., the percentage of PRs merged within the timeframe described in the paper) was very similar between the two collaboration patterns: 81.2% for single-reviewer pull requests and 80.3% for multi-reviewer\/committer pull requests,\u201d Raida said<\/p>\n

The two groups do different jobs. According to Raida, \u201cthe most common type of PR among single-reviewer workflows was feature-related, whereas fix-related PRs were the most common among multi-human workflows.\u201d Solo maintainers point their agents at new functionality. A crowd shows up for the repairs<\/p>\n

Those numbers cover acceptance inside the study window and stop there. Reverts, follow-up bug fixes, and how well merged agent code holds up over time sit outside the dataset<\/p>\n

The one-person review desk<\/h3>\n

The pattern is ordinary practice, familiar to anyone who has merged their own Copilot output on a quiet afternoon, and it holds up under load. Small teams running dozens of agent pull requests kept one person in the loop the whole time. Few projects have pushed hard enough against that ceiling to find out where it gives<\/p>\n

\"\"<\/p>\n

Must read:<\/strong><\/p>\n