# AI-coding agents kill team collaboration > [!question] Lingering Questions > - The study is observational, drawn from public GitHub repositories — it describes open-source and public-facing work, not private enterprise codebases where adoption and mandates may differ sharply. > - "Agent-generated PR" detection methodology isn't described in the article — worth checking the underlying arXiv paper directly before treating any of the percentages as precise. > - The article's own headline asserts causation ("kill team collaboration"), but the data supports correlation/co-occurrence at best — it doesn't establish agent use *caused* collaboration to decline versus agents being adopted first by people already working solo. > [!tip] Article Ideas > - The 79% self-review rate is independently checkable inside any organization today, without any research apparatus: compute the author-equals-reviewer rate on your own agent-assisted PRs, alongside the same rate for human-authored PRs — the missing baseline in the source article is the piece's biggest evidentiary gap and the easiest one to close locally. > [!link] Cross Reference > - [[3. Resources/MOCs/Open Source Governance MOC]] — contributor tooling rollout without a shared learning ritual is a volunteer open-source failure mode, not just an enterprise one > - [[3. Resources/Permanent Notes/Automating Both Ends Of A Review Collapses Its Value]] — same underlying mechanism (self-review/self-mediated review erodes review's knowledge-transfer function), different source article > [!quote] Vocabulary > - none flagged — reporting-register vocabulary throughout, no specialized terms introduced ## Metadata - Source: [[3. Resources/Readwise/Articles/AI-coding agents kill team collaboration]] - Author: Chris Stokel-Walker - Type: article - URL: https://leaddev.com/ai/ai-coding-agents-kill-team-collaboration ## Author's thesis Agentic coding has not become a team practice: an analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found shallow, uneven adoption (median one or two agentic PRs per project over three months) and, where agents were used, a structurally solitary workflow — 79% of agentic PRs were reviewed and modified by the same person who prompted the agent, collapsing the second-pair-of-eyes function of code review exactly when output volume rises. ## Key arguments (≤3) 1. **The core empirical claim is a management finding, not a technology finding**: individual access to agents does not aggregate into team capability, and treating adoption as an individual's responsibility (per Courtney Miller, GWU) is the specific mistake — organizations grant tool access, promise large productivity gains, and leave individuals to work out how to deliver them. 2. **Self-review is the most consequential, most actionable number**: the 79% same-developer-reviews-and-modifies rate describes a structural loss of the second pair of eyes at precisely the moment agents make output volume easier to increase — measurable in any organization's existing GitHub/GitLab data without a research apparatus. 3. **Individually tunable agents silently fork team process**: each engineer develops private prompting and correction habits, so teams that started with a shared workflow end up with divergent ones — a variance problem, not a quality problem, and a specific risk for junior engineers who lack the experience to evaluate an agent's output the way they'd evaluate a colleague's. ## Claim atoms ### Agent-generated PRs are overwhelmingly self-reviewed > [!quote] ID:rw_pending > in 79% of agentic PRs, the same developer both reviewed and modified the AI's contribution The single most actionable number in the piece — measurable in any repository today. Weakened by the absence of a non-agentic baseline, which should be computed alongside it. ### Writing code was never the engineering bottleneck > [!quote] ID:rw_pending > Software development is not an isolated task, and writing new code was never the hard part Courtney Miller's line locates the argument correctly — accelerating generation may not produce throughput gains if it speeds a step that was never the constraint. ### Individually tuned agents fork a team's shared process > [!quote] ID:rw_pending > You can kind of end up in this situation where you just suddenly have very different processes, even though you started from the same place Supplies the causal mechanism the headline needs and the cross-sectional data alone can't provide — suggests a diagnostic nobody currently runs: measure dispersion in agent usage patterns within a team, not just mean adoption. ## Permanent candidates - **Tool access does not aggregate into team capability** — distributing a capability to individuals doesn't produce that capability at the team level unless a shared learning surface converts private practice into common practice. Promoted below. ## Processing checklist - [x] Verify no existing Literature Note covers this doc (checked, none found) - [x] Extract claim atoms and permanent candidate from the existing deep-read - [ ] Compute the author-equals-reviewer rate locally, alongside a human-authored-PR baseline, before repeating the 79% figure as precise - [x] Connect into the relevant MOC — [[3. Resources/MOCs/Open Source Governance MOC]] ## Links - [[3. Resources/MOCs/Open Source Governance MOC]] — tooling rollout and review-process design for volunteer and paid contributors alike - [[3. Resources/MOCs/AI & the Future of Knowledge Work MOC]] — applies-in: agent adoption as an organizational capability question, not just an individual-productivity one