Are We All Using Agents the Same Way? An Empirical Study of Core and Peripheral Developers Use of Coding Agents

Autonomous AI agents are transforming software development and redefining how developers collaborate with AI. Prior research shows that the adoption and use of AI-powered tools differ between core and peripheral developers. However, it remains unclear how this dynamic unfolds in the emerging era of autonomous coding agents. In this paper, we present the first empirical study of 9,427 agentic PRs, examining how core and peripheral developers use, review, modify, and verify agent-generated contributions prior to acceptance. Through a mix of qualitative and quantitative analysis, we make four key contributions. First, a subset of peripheral developers use agents more often, delegating tasks evenly across bug fixing, feature addition, documentation, and testing. In contrast, core developers focus more on documentation and testing, yet their agentic PRs are frequently merged into the main/master branch. Second, core developers engage slightly more in review discussions than peripheral developers, and both groups focus on evolvability issues. Third, agentic PRs are less likely to be modified, but when they are, both groups commonly perform refactoring. Finally, peripheral developers are more likely to merge without running CI checks, whereas core developers more consistently require passing verification before acceptance. Our analysis offers a comprehensive view of how developer experience shapes integration offer insights for both peripheral and core developers on how to effectively collaborate with coding agents.

💡 Research Summary

**
This paper presents the first large‑scale empirical investigation of how developers with different levels of project experience interact with autonomous coding agents. The authors collected 9,427 closed pull requests (PRs) on GitHub that were generated by four widely used agents—Claude, GitHub Copilot, Cursor, and OpenAI Codex—between January 2025 and August 2025. After applying quality filters (minimum 100 stars per repository, removal of PRs created before agents existed, exclusion of open PRs, and elimination of developers who contributed to more than one repository), the final dataset comprised 1,701 unique developers across 1,391 repositories.

Developer experience measurement and classification
Instead of the traditional commit‑count metric, the study adopts a PR‑based experience score: the normalized sum of authored and reviewed closed PRs for a given developer in a repository. Developers whose scores fall in the top 20 % (the 80th percentile) are labeled “core developers,” while the remaining 80 % are labeled “peripheral developers.” This approach captures both code contribution and review activity, reflecting the shift from pure coding to coordination that typically accompanies core status.

Research Questions and Findings

RQ1 – Frequency and purpose of agent use
Overall usage frequency of agents is similar between core and peripheral groups, but a subset of peripheral developers uses agents disproportionately often. Using a GPT‑4‑based classifier aligned with a ten‑category taxonomy (bug fix, feature, refactor, docs, test, build, style, CI, performance, chore), the authors find that peripheral developers delegate tasks evenly across bug fixing, feature addition, documentation, and testing. Core developers, by contrast, concentrate agent usage on documentation and testing, reflecting their responsibility for maintaining project stability and quality.

RQ2 – Review intensity and issue types
Core developers post slightly more review comments per PR than peripheral developers. Both groups focus primarily on “evolvability” concerns—code organization, alternative design approaches, and maintainability. Peripheral developers tend to raise issues about code organization and readability, whereas core developers more often discuss alternative solution strategies and higher‑level architectural considerations.

RQ3 – Modification intensity and types
Across the entire corpus, 74.1 % of agent‑generated PRs are merged without any post‑submission modifications, indicating that agents can produce high‑quality contributions. When modifications do occur, the dominant change type is refactoring, suggesting that developers (both core and peripheral) use refactoring to improve readability or align with project conventions rather than to fix functional defects.

RQ4 – Verification outcomes (CI checks)
A striking divergence appears in CI verification: peripheral developers are more likely to merge PRs without all CI checks passing, whereas core developers almost always require successful CI runs before merging. This reflects a cultural difference: core contributors prioritize automated quality gates, while peripheral contributors may accept higher risk for speed or may lack awareness of CI policies.

Implications
The study reveals that experience shapes not only how often agents are invoked but also the nature of tasks delegated, the rigor of review, the propensity to modify generated code, and adherence to CI pipelines. For organizations adopting AI coding agents, the findings suggest tailoring guidelines and training to developer roles: provide “fast‑track” best‑practice templates for peripheral contributors who seek rapid assistance, while reinforcing strict CI enforcement and deeper architectural review for core maintainers. Moreover, the high proportion of unmodified agent PRs underscores the maturity of current agents, yet the prevalence of refactoring indicates a continued need for human oversight to ensure stylistic and structural alignment.

Limitations and Future Work
The authors acknowledge that the PR‑based experience metric may not capture all dimensions of expertise (e.g., issue‑tracking activity, community reputation). The study is limited to open‑source projects on GitHub and to four agents; results may differ for proprietary settings or emerging agents. Future research could longitudinally track the maintenance cost of agent‑generated code, compare agent‑assisted code review tools, or explore how mixed human‑agent collaboration evolves as agents gain more autonomy.

In sum, this paper provides a comprehensive, data‑driven portrait of how core and peripheral developers differ in their interaction with autonomous coding agents, offering actionable insights for researchers, tool builders, and software engineering managers seeking to integrate AI assistance into diverse development workflows.