A developer named Andrew Vos recently published a plugin called Endless Toil. It runs alongside your coding agent in real time, scanning the code being processed and playing escalating human groans based on how cursed things look. A mild mess earns a soft whimper. A true atrocity gets the full wail. At the deepest level, labelled "abyss," your speakers emit something between existential dread and a man stepping on a Lego in the dark.
Hacker News loved it. Of course they did. It's funny. It's relatable. Every developer has opened a file and made exactly that sound.
But here's the thing nobody seemed to ask: why is the agent groaning in the first place?
The charm of making it visceral
Credit where it's due. Endless Toil works because it takes something invisible and makes it physical. Code quality metrics are abstract. Cyclomatic complexity scores don't make you feel anything. But a recorded human moan triggered by a 400-line function with six levels of nesting? That lands differently.
We've been staring at red squiggly lines and yellow warning triangles for decades. Sometimes the signal needs to bypass your prefrontal cortex and hit somewhere more primal.
The accidental code quality metric
Strip away the humour and what you have is a tool that measures how hard an AI agent finds your code to work with.
That's not a joke metric. That's a genuinely useful signal.
If your agent struggles to navigate your codebase, if it loses context, produces wrong suggestions, or takes three attempts to make a change that should be trivial, that tells you something real about your architecture. Not about the agent's limitations. About the density, coupling, and comprehensibility of what you've built.
Agent friction is code quality feedback. The groaning is the metric.
The great toil shift
This matters more than it sounds. We're living through what Sonar's 2026 developer survey calls "the great toil shift." The numbers are stark:
- 88% of developers report AI has at least one negative impact on technical debt
- 53% say AI generates code that looks correct but introduces hidden defects
- 96% don't fully trust AI output, yet only 48% actually verify it
We haven't eliminated the tedious work. We've moved it. Less-frequent AI users struggle with debugging poorly documented code and understanding legacy systems. The most frequent AI users? Their toil has shifted to managing technical debt and correcting code that AI generated.
The developers who lean hardest on AI are spending their time cleaning up after it.
The productivity paradox is real: developers report a 35% personal productivity boost while simultaneously generating code that requires more verification, more maintenance, and more cognitive overhead to understand.
Comprehension debt
Addy Osmani gave this problem a name earlier this year: comprehension debt. It's the growing gap between how much code exists in your system and how much of it any human being genuinely understands.
Traditional technical debt is code you chose to write poorly. Comprehension debt is code that nobody fully understands, because it was generated faster than anyone could internalise it. I wrote about this accumulation pattern before as the lava layer: code that flows fast and looks impressive, but solidifies into rock that nobody dares touch.
An Anthropic study from January 2026 put a number on it: developers who used AI assistance scored 17% lower on comprehension quizzes about the code they'd just written. They finished the task in roughly the same time. They produced working code. But they understood less of what they'd built. The steepest decline was in debugging ability. Exactly the skill you need when things go wrong at 3 AM.
Your agent isn't just groaning at your legacy code. It's groaning at the code it helped write last week that nobody reviewed properly. The brilliant parrot doesn't remember what it said yesterday, but it still has to read it back.
The verification vacuum
Here's the uncomfortable pattern:
- Agents generate code faster than humans can review it
- Humans trust the output because it looks correct
- The resulting codebase becomes harder for both humans and agents to navigate
- Which makes agents less effective, which makes developers lean harder on them anyway
It's a feedback loop, and it's tightening. The 96%-don't-trust-but-only-48%-verify gap from Sonar's data isn't a curiosity. It's a structural failure in how teams are adopting AI tooling. We've created a verification vacuum where generated code enters the codebase without meaningful scrutiny, then accumulates into the kind of mess that makes agents groan.
What to actually do
If you take one thing from Endless Toil beyond a laugh, make it this: treat agent friction as signal.
- If your agent struggles, refactor first. Before asking an AI to add features to a module it can barely parse, simplify the module. The agent's confusion is showing you where your abstractions leak.
- Monitor code turnover rate. Track how much AI-generated code gets reverted or rewritten within 30 days. Healthy teams stay under 15%. If you're above that, you're not shipping. You're churning.
- Close the verification gap. If you don't have time to review AI output properly, you don't have time to use AI. Unreviewed code isn't velocity. It's future debugging sessions wearing a productivity costume.
- Make the invisible visible. Whether it's Endless Toil's groans, complexity dashboards, or turnover metrics, find a way to make the cost of AI-generated complexity felt, not just measured.
The punchline
The funniest tools sometimes tell the hardest truths. Endless Toil landed as a joke, but the insight underneath is dead serious: your agent's suffering is a mirror.
It's not groaning because it's weak. It's groaning because your codebase is telling it something that your IDE, your CI pipeline, and your sprint metrics have all been too polite to say out loud.
Maybe listen.