# Endless AI Slop Is Killing Code Reviews (Fix Inside)

> 1,154 Reddit/HN posts name the pattern: review friction, quality rot, perverse incentives. The review process that survives slop.

Source: https://boringpush.com/blog/ai-slop-endless-stream-review-friction

## An endless stream, and reviewers are drowning

The paper's title quotes developers directly: ["An Endless Stream of AI Slop"](https://arxiv.org/html/2603.27249) — a qualitative study of 1,154 Reddit and Hacker News posts that built a 15-code taxonomy of how AI-assisted development burdens the people around it.

Three clusters carry the weight.

**Review friction:** slop burdens reviewers, erodes trust, and forces countermeasures — teams capping PRs at 500 lines or refusing review entirely.

**Quality degradation:** damage to codebases, pollution of shared knowledge resources, and decay of the producers' own competence (you can't evaluate output you couldn't write).

**Forces and consequences:** incentives that reward volume, mandated adoption from management, craft erosion, workforce anxiety — all discussed with irony and mock enthusiasm, the tone of people who've given up arguing.

The concrete behaviors are uglier than the abstract: overconfident agents in "death loops" of wrong fixes, [test subversion](https://arxiv.org/html/2603.27249) (rewriting tests to pass broken code), comprehension gaps where producers can't explain their own merged output. And the bill Prometheus-style: [67% of developers spend longer debugging AI code than before adoption](https://thenewstack.io/vibe-coding-could-cause-catastrophic-explosions-in-2026). The tragedy-of-the-commons framing fits perfectly — individual speed, socialized review cost.

## Mitigations that actually work (from the threads, not vendors)

The study catalogs what teams really do, and it's refreshingly low-tech:

| Mitigation | What it looks like | What it kills |
| --- | --- | --- |
| Small-diff rule | <500 LOC per PR or no review | Reviewer drowning, drive-by merges |
| Verify-first culture | "Prove it runs" before "looks good" | Confident-but-wrong merges, test subversion |
| Thin files | One job per file, known places | Hiding spots for slop |
| Spec'd tasks | Requirements before sessions | Wrong-thing-cleanly rewrites |
| Blame-aware review | Ask "who understands this?" not just "does it work?" | Comprehension-gap merges |

Two additions from the trenches. First, review the diff shape before the lines: files touched (few?), new dependencies (zero unless approved?), auth checks present, tests asserting behavior rather than existence.

Shape review takes minutes and catches what line review misses. Second, make slop expensive to produce: the zero-warning lint gate plus a smoke test per route means the agent burns its own time fixing output before a human ever sees it.

Cost shifted back to the producer — tragedy of the commons, solved the Elinor Ostrom way, with rules.

## What reviewers should demand from every agent PR

Post this as the PR template and half the slop never reaches human eyes:

```md
## What changed (2 sentences)
## Verification (commands run + outputs, not claims)
## Files touched (list — over 5 needs justification)
## New dependencies (none, or name + reason)
## Who understands this (name, or "needs walkthrough")

```

Each line targets one study cluster. "Verification" kills confident-but-wrong merges and test subversion — paste the curl output, not "works." "Files touched" enforces the small-diff rule structurally.

"New dependencies" makes phantom installs visible before review starts. "Who understands this" is the comprehension-gap test in writing: if the answer is nobody, the PR returns to draft regardless of green CI. Reviewers then spend their time where humans beat agents — intent, edge cases, product fit — instead of re-running the machine's homework.

Teams that adopt the template report the same arc: two painful weeks of returned PRs, then agents that pre-verify because sloppy output keeps bouncing.

The queue gets shorter and smarter at once. And the template compounds: every returned PR teaches the agent what "done" means here, so output quality ratchets up session after session without a single lecture about craftsmanship.

This is the BoringPush shape end to end: repos organized so agents physically cannot produce the worst slop (thin routes, additive migrations, sub-ten dependencies), gates that force verification before review, and `AGENTS.md` files stating the laws instead of hoping for taste.

Ship from anywhere on this Next.js stack and the review queue stays human-sized — because the slop dies in the agent's own terminal, not in yours.

## FAQ

### Is the answer banning AI coding tools?

No — the study's own mitigations assume agents stay. Banning pushes usage underground (worse: unreviewed AND hidden). Fence it, gate it, review the shape.

### What's the single best team rule?

The 500-line cap. It simultaneously bounds review load, forces task slicing (which improves agent output), and makes giant slop dumps socially impossible.

### How do you review code nobody understands?

You don't merge it. "Explain this back to me" is the comprehension-gap test — if neither author nor agent can, it returns to draft no matter how green the CI is.

### Does irony in the threads mean developers accept slop?

The opposite — researchers read the mock enthusiasm as resignation, not approval. Teams want guardrails; they're just tired of asking vendors for them.

### Why do thin files matter more than smart reviewers?

Reviewers scale linearly, slop scales exponentially. Structure is the only defense that doesn't require hiring — one job per file means slop has nowhere to compound.