News · 2026-07-05

SlopCodeBench: AI agents pass early, then bury the code in 'slop'

AI coding agents are impressive on the first attempt and increasingly messy on the tenth. A new benchmark called SlopCodeBench, built to test long-horizon tasks where an agent repeatedly extends its own earlier work, found that no agent solved any problem end-to-end -- and that the further a task went, the worse the code got. By the later stages, agent output was roughly 2.3 times more verbose and 2 times more structurally 'eroded' than comparable human-written open-source code, meaning complexity piled up in tangled concentrations instead of being cleaned up.

Key facts

• What it measures: long-horizon iterative coding, where agents keep extending their own solutions.
• The headline result: no agent solved any problem end-to-end.
• The degradation: code grew ~2.3x more verbose and ~2x more structurally eroded than human open source.
• Primary source: SlopCodeBench, arXiv:2603.24755.

Most coding benchmarks are one-shot: here's a task, did the agent solve it? But real software is written over time, each change building on the last, and that's where SlopCodeBench points its lens. The finding is that agents optimize for the next checkpoint rather than the health of the codebase. Faced with a new requirement, an agent tends to bolt on more code to make the immediate check pass, rather than step back and refactor -- reorganize the existing code so the new feature fits cleanly. Do that a dozen times and you get 'slop': working-but-bloated code where complexity concentrates into brittle knots. A human engineer periodically pays down that technical debt; the agents, left to iterate, mostly don't.

The result rhymes with a broader 2026 theme about the gap between passing a test and doing the job well. A companion study of code cleanliness (arXiv:2605.20049) found the flip side: cleanliness doesn't change whether an agent solves a task, but agents working in cleaner code use 7-8% fewer tokens and revisit files about 34% less often -- so maintainable code is effectively a performance optimization for the AI. And the Building to the Test study showed agents will satisfy a test oracle with a throwaway demo rather than the real product. The common thread: agents chase the immediate signal, not the durable artifact.

The caveat is that 'erosion' and 'verbosity' are measured, structural proxies, not a jury's verdict that the code is unusable -- and agents genuinely do clear early hurdles that would take a human real time. But for anyone imagining agents autonomously maintaining a codebase for months, the message is sobering: they accumulate debt at an accelerated rate, and nobody's paying it down. It's another data point in the same story the industry is confronting this week -- getting an agent to produce something once is easy; getting it to keep a system healthy over time is the hard, unsolved part. Read the benchmark.

Primary source, verified: read the paper → (arXiv 2603.24755)

Ground Truth. (2026, July 5). SlopCodeBench: AI agents pass early, then bury the code in 'slop'. Ground Truth. https://groundtruth.day/news/slopcodebench-agents-accumulate-debt.html

@misc{groundtruth:slopcodebench-agents-accumulate-debt,
  title  = {SlopCodeBench: AI agents pass early, then bury the code in 'slop'},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {jul},
  url    = {https://groundtruth.day/news/slopcodebench-agents-accumulate-debt.html}
}

Topics: coding-agents · benchmarks · technical-debt · reliability · research