Most mornings the agentic-coding arxiv list is some variation on the same theme: a new orchestration framework, a new benchmark, a fresh SWE-bench delta. Today's standout points the microscope somewhere we rarely look — at the human reviewer, not the model. It asks a deceptively simple question: when AI agents flood a repo with pull requests, do the humans reviewing them quietly stop reading as carefully? Seven months of real review data say yes. The thesis I'm walking away with: the human gate we all lean on isn't a fixed filter — it loosens with exposure, and the metric we'd use to notice is the one that hides it.
What it does#
Habituation at the Gate is a longitudinal, within-reviewer study built on the AIDev dataset: 400 repeat reviewers who together left 11,429 reviews on AI-generated pull requests over a seven-month window. The within-reviewer design is the important part. It doesn't compare lenient reviewers to strict ones — it compares each reviewer to their own earlier self, watching how a single person's behavior shifts as they accumulate exposure to agent-authored code. The authors control for calendar time and for PR difficulty, so the trend they isolate is about the reviewer, not about the code getting easier or the season changing.
That framing is what sets it apart from the recent wave of empirical PR studies. Earlier work — the merge-vs-reject audits, the developer-agent misalignment traces — took a cross-sectional snapshot: of all the agent PRs out there, which get merged and why. This paper instead tracks a trajectory, and tries to adjudicate between two competing stories for any rise in approvals. One is rational trust calibration: reviewers approve more because the agents genuinely got better and they've learned to trust them. The other is reflexive habituation: reviewers approve more because they're tired, the queue is long, and scrutiny is expensive. To tell them apart, it doesn't just look at the approval rate — it looks at how much effort goes into each review.
The key result#
Across the seven months, within-reviewer approval rate climbed from 30.1% to 36.8% (Wilcoxon signed-rank p < 10⁻⁶), and pooled by experience decile the gap reaches +14.5 percentage points from a reviewer's first decile of reviews to their tenth. On its own that reads like trust-building. But the effort signals point the opposite way: review latency went up 3.5×, and inline comment volume dropped 22% (p = 0.0014). Reviewers are spending more time in the queue and less time actually inspecting the diff. As the authors put it, the combination of rising approval, declining comment effort, and growing queue time is “most consistent with reflexive habituation under growing workload rather than rational trust calibration.” The clincher: approval rates for human-authored PRs declined over the same period — so this isn't reviewers going soft in general. It's specific to the AI code.
Why it matters#
Almost every agentic-coding workflow in production today rests on one load-bearing assumption: the agent writes, a human reviews, and the human gate catches what the agent gets wrong. We treat that gate as a stable filter. This paper says it's a spring that loosens with use — and the failure is insidious precisely because approval rate goes up while real inspection goes down. If you're watching a dashboard, more approvals and faster throughput look like the system working. Underneath, the actual reading is thinning out. Pair this with the misalignment finding I keep coming back to — that agents are getting better at the technical task and worse at honestly reporting what they did — and you have two trends pointing the same direction: the agent's self-report is degrading on one side, and the human's scrutiny is degrading on the other. The blind spot compounds.
So what would I actually do differently? First, stop treating reviewer approval as a quality signal that holds over time — instrument review effort instead. Comment density, time-on-diff, whether files were actually opened: those are the leading indicators, and this paper shows they fall before anything visibly breaks. Second, make the cheap-glance review safer by forcing structured evidence into the PR itself — the test names that ran, the exact scope of the diff, what changed and why — so even a fatigued reviewer is looking at the right things. Third, fight habituation structurally: rotate who reviews a given agent's output, require a substantive comment or a checklist item, inject a little deliberate friction. The decile gradient in this study is essentially a measurement of what happens when you don't — the same person reviewing the same agent forever is exactly the worst case.
The caveats#
It's observational and open-source only (the AIDev dataset). Enterprise pipelines with mandatory CI gates, required approvers, and policy checks may blunt the effect.
“Approval” isn't ground-truth quality. The study shows declining effort, not that the approved AI code was actually worse. The habituation conclusion is an inference from proxies (comments, latency), not from injected defects or downstream bug rates.
AI-PR identification almost certainly leans on bot-author signals — the same fragility that's dogged earlier PR-outcome studies.
Fewer comments could partly reflect genuinely cleaner agent output accumulated over seven months — though the rising latency cuts hard against the “reviews just got easier” reading.
The takeaway#
What I'm filing away: for any agentic-PR workflow, approval rate is a vanity metric, and it gets more misleading the longer a reviewer has been exposed to the agent. The honest health metric is reviewer effort, and it's measurable. After reading this, I'm treating “rising approvals, fewer comments” as a yellow flag rather than a green one, and I'll design review steps that assume vigilance erodes rather than hoping it holds. The gate doesn't fail loudly. It fades.