Humans Were Writing Code Slop Long Before AI Got the Blame

"Slop" was Merriam-Webster's Word of the Year in 2025. The definition: low-quality digital content produced in quantity by artificial intelligence. The entire industry rallied around this term like they'd discovered a new species of bug. AI slop. Slop PRs. Slop code. Mitchell Hashimoto considered closing external PRs to his open source projects entirely because he was drowning in LLM-generated contributions. Open source maintainers are burning out reviewing garbage submissions. The curl project reported that only 5% of bug bounty submissions were genuine vulnerabilities, with roughly 20% appearing to be AI-generated noise.

Real problems. I'm not dismissing them.

But here's what nobody seems willing to say out loud. Humans have been producing code slop at industrial scale for decades. We just didn't have a catchy word for it.

I See the Receipts

At CircleCI, we process over 1 million builds daily across 30,000+ organizations. I sit on top of one of the largest data sets of how software actually gets built, tested, and deployed. And let me be direct about what that data reveals.

The overwhelming majority of code quality failures we see are human-generated. They always have been.

Brittle test suites that fail on Tuesdays for no discernible reason. Configuration files copy-pasted from Stack Overflow in 2019 and never touched since. Build pipelines that haven't been updated across three major framework versions. Flaky integration tests that everyone just re-runs until they pass. Entire microservices that nobody on the current team understands but everyone's afraid to touch.

That's not AI slop. That's human slop. And it costs $1.52 trillion annually in technical debt in the US alone. Stripe's data shows developers spend 42% of their working week dealing with technical debt and bad code. That's 13.5 hours per developer, every week, fighting the consequences of human decisions.

We didn't call it slop when humans wrote it. We called it "tech debt" and accepted it as the cost of doing business.

The Double Standard Is Absurd

Think about what we're actually saying as an industry. When a human writes spaghetti code with no tests, ships it to production on a Friday afternoon, and disappears for the weekend, we call that "moving fast." When they copy-paste the same authentication logic into four different services because they didn't feel like extracting a shared library, we call that "pragmatic." When they write a 3,000-line god class that handles user authentication, payment processing, and email notifications, we call that "legacy code."

But when an AI generates a function with a subtle edge case bug? Slop. Unusable. Proof that machines can't code.

The Qodo State of AI Code Quality report found that 84% of developers are using AI tools in their workflows. And yes, AI-generated code introduces quality issues. Sonar's research documents copy-pasted code rising significantly, surpassing moved code around 2022. Code churn is projected to hit nearly 7% by 2025, a red flag for instability.

But here's the thing. Code churn, copy-paste proliferation, untested functions, security vulnerabilities. None of these problems are new. They all existed before a single line of AI-generated code entered a production system. We had all of these problems in 2015. We had them in 2005. We had them in 1995.

The difference is that nobody made "human slop" the Word of the Year.

The Real Advantage Nobody's Talking About

Here's where my perspective gets contrarian. AI slop might actually be better than human slop. Not because the code quality is higher. It's often not. Because of the failure timeline.

When a human writes bad code, it can hide for months. Years. That 3,000-line god class? It works fine until traffic spikes 10x and the whole thing collapses. The copy-pasted authentication logic? Nobody notices until someone patches one instance and forgets the other three, creating a security vulnerability that sits undetected for six months. The flaky test suite? Teams just re-run the pipeline and pretend everything is fine until one day they deploy a regression to production.

Human slop is slow poison. It accumulates. It hides. It compounds.

AI slop fails fast. When an AI-generated PR hits a CI/CD pipeline, the problems surface in minutes. The tests catch it. The linter flags it. The build breaks. The code review surfaces the issues immediately because the reviewer knows to look for them. The feedback loop is measured in minutes, not months.

At CircleCI, we see this daily. AI-generated code that fails a build gets caught in the same pipeline run that triggered it. The turnaround from "bad code generated" to "bad code identified" is single-digit minutes. Compare that to human-generated technical debt that sits in production for an average of 40+ developer hours per month in debugging, refactoring, and maintenance.

Which kind of slop would you rather deal with? The kind that announces itself on arrival, or the kind that waits until 3 AM on a Saturday to detonate?

The Uncomfortable Truth About Quality

I want to be specific about something. I'm not arguing that AI-generated code is good. Much of it isn't. The research shows that developers using AI assistants can produce less secure code while simultaneously being more confident in its security. That's dangerous. AI-generated code often lacks architectural judgment. It solves the immediate problem without understanding the system-level consequences.

But the uncomfortable truth is that humans do exactly the same thing. They just do it slower.

A junior developer writes code that solves the ticket without understanding the broader architecture. A senior developer under deadline pressure takes shortcuts they know they'll regret. A team lead approves a PR they barely read because there are 47 more in the queue. An architect designs a system on a whiteboard that looks clean but ignores the operational reality of running it at 2 AM when the on-call person is half asleep.

We've normalized human slop. We've built entire industries around managing it. Configuration management. Code review tools. Static analysis. Observability platforms. Incident response processes. All of this infrastructure exists because humans produce unreliable code at scale. We spent decades and billions of dollars building safety nets for human fallibility.

Now we're panicking because AI is fallible too. As if this is somehow surprising.

What Actually Matters

So what's the productive move here? Stop treating AI slop as a categorically different problem from human slop. It's the same problem with a different author.

The real question isn't "how do we prevent AI from writing bad code." It's the same question we've been asking for 50 years: "how do we catch bad code before it reaches users?"

And the answer is the same. Strong CI/CD pipelines. Automated testing. Static analysis. Code review. Observability. Production monitoring. The same infrastructure that catches human mistakes catches AI mistakes. The difference is that AI mistakes surface faster, which means the same infrastructure works better against them.

If your pipeline can't catch a bug introduced by an AI agent, it probably wasn't catching the same bug when a human wrote it either. The AI just exposed the gap faster.

This is actually the optimistic take. AI slop is a forcing function for better engineering practices. Teams that relied on "trust the senior engineer" as their quality strategy are now forced to build actual automated validation because AI doesn't have ten years of institutional knowledge to fall back on. The teams building strong pipelines, real test coverage, and proper validation aren't worried about AI slop. Their systems catch it. Same as they catch human slop.

The Honest Position

Here's where I land on this. We should absolutely hold AI-generated code to high standards. We should build better tools for detecting and preventing quality issues in AI output. We should invest in the developer experience of reviewing AI-generated code.

But we should also be honest about where we're coming from. The $1.52 trillion in annual technical debt didn't come from ChatGPT. The flaky test suites clogging CI/CD pipelines across the industry weren't generated by Claude. The copy-pasted Stack Overflow answers running in production at Fortune 500 companies were written by humans.

AI slop is real. But it didn't invent the problem. It inherited it. And at least it has the decency to fail where we can see it.

The next time someone tells you AI is ruining code quality, ask them one question: compared to what?

Humans Were Writing Code Slop Long Before AI Got the Blame