The author argues that AI agents are both creating and maintaining codebases, questioning the predicted need for human cleanup armies, and suggests that the mid-level developer role is being squeezed.
There's a recurring framing in the press at the moment that goes something like this. AI tools let bad developers ship faster. Those codebases will rot. In year two, somebody has to come back and fix it. Cue the inevitable "the humans will be needed again" closer. I've been running a fair amount of agentic work over the last year. Claude Code in one window, Codex in another, a handful of longer-running runners chewing on cron jobs and background tasks. Not a wild setup, plenty of people here are doing the same. And the thing I keep noticing, that I don't see talked about much, is that the maintenance work is going to the same agents. When something breaks in a repo that an agent built, I don't open VS Code. I open Claude Code, point it at the failing test, and let it work. When a dependency moves and three things shift under it, same loop. When the schema changes and a migration needs hand-holding, same loop. The agent that wrote the original slop is the one cleaning up the slop. It is genuinely fine at it, because it can read the whole repo at once in a way I cannot, and it doesn't get bored. It is worse than me at some things and better than me at others, and on the boring grind of maintenance it is plainly better. So the question I keep coming back to is: where exactly is the human cleanup army supposed to come from? If you're running this stack you know what I mean. The agent built it, the tests are passing for the wrong reasons, you let the agent loose with a tighter eval harness and it actually fixes the wrong-reason tests. You don't need a senior engineer to wade through that. You need an operator who can read what the agent did, decide if it matches the outcome, and write a better prompt or a better test if it doesn't. That role exists. Plenty of people in this sub are doing it already. But it isn't the mid-level developer's job. The mid-level engineer in the traditional sense (ticket comes in, write the code, write the tests, raise the PR, get reviewed) is the role that gets squeezed, because the ticket-to-code part is what agents are best at and the review part is what gets pushed up the stack to whoever is operating the agent. The juniors I see thriving are the ones who treat the agent as a peer they have to manage, not a typewriter that types faster. The seniors who are thriving are the ones who set up the eval scaffolding and the architecture and let the agents grind. I don't see a corresponding seat in the middle. I am not trying to be edgy about this. I would genuinely like to be wrong. If you're running agents in production and you've found a clean operator-shaped role for a mid-level engineer that isn't "be a junior with more years" or "be a senior with less scope", I want to hear what that looks like. And if you're maintaining a year-old agent-built repo by hand because the agent can't, I want to hear that too, because I have not seen it happen. The cleanup army I keep being told is coming might just be the same agents, with better evals around them.
George Hotz argues that adopting AI agents for software development is a costly mistake, as they produce increasingly hard-to-detect slop rather than reliable code. He cautions that large organizations will be hurt more than individuals by this trend.
The article argues that the proliferation of low-quality, AI-generated content ('AI slop') on platforms like GitHub and blogs is degrading the value of online technical communities.
The article analyzes how AI agents disrupt traditional code review processes, creating a 'principal-agent problem' where reviewers cannot effectively gauge effort or quality, leading to an increase in low-quality 'slop PRs' in open source.
The author proposes using AI as a research moderation and synthesis tool rather than a content generator to combat 'AI slop.' By building a pipeline that compares and ranks expert sources, the author argues the future human role in AI is curation and judgment.
James Shore argues that AI coding agents must significantly reduce long-term software maintenance costs to deliver real productivity gains, rather than just speeding up initial code writing. The article highlights the 'Wisdom of the Crowd' estimates on maintenance burdens and warns that without lowering these costs, teams face diminishing returns and technical debt.