You Don't Have to Ship Slop, You Know
You are a really smart and really experienced Senior/Staff Software Engineer, remember? You don't have to ship slop if you don't want to.
Online discourse has convinced you that you are powerless against poor code contributions. You totally aren't! The Internet Gripe Establishment wants you to give up so they feel better about not improving their own situation! Don't do that!
Everywhere I look, I see immense doom and gloom about our codebases rotting, our responsibilities decaying, and our apps crumbling under AI slop contributions. We're powerless against those that wield the slop cannons. Our beautiful code gardens incinerated by slop napalm.
Except You Can Just Do Something About It#
In fact, there are really obvious things you can do. But you have been convinced by people much less smart than you that there's nothing you can or should be doing to improve your situation. You simply cannot stop the slop from being shoveled into your house. This is simply the reality of software development now. It's over, don't you see?
Look, software development has changed. It's changed a lot. I'm not going to lie to you and say it hasn't. Humans aren't really writing code anymore. This part is true. But the fundamentals have only become more important, not less! Those old theories about software correctness, and criteria, and specifications, and rules that you learned in university are important now! Things like the Single responsibility principle, Open-close principle, Liskov substitution principle, Interface segregation principle, and Dependency inversion principle 1. We were lucky to go so long without ever having to think about that boring stuff.
Now that agents are writing most of the code, we can enforce the highest levels of quality that we want. Have you ever wanted to enable a bunch of lint rules but were worried that you would be disrupting people's workflow? You fear that they won't be able to meet your quality bar? Yeah, that doesn't matter anymore. You can enforce the strictest code requirements without hurting anyone's feelings. Agents don't care that their PRs fail the CI pipeline. They don't care that they forgot to format the code before they pushed. They don't care that they just got dinged on 20+ lint rules. They get the feedback they need and just fix it.
So Start Thinking About How Good Your Static Analysis Is#
Does it check types? Does it detect unhandled cases? Unused variables and imports? Immutability? Let's go further: Does it enforce modularity? SOLID? How powerful is your linter? Can you write custom rules easily?
Are you using Oxlint, or Ruff, or Clippy? What new tools have you found that enforce Anti-slop patterns? Have you even looked?
If your gut reaction to a bad PR is to prompt your agents to fix it, then you are (and it pains me to say this) holding it wrong. Instead, you should be thinking: why didn't the agent get feedback through tooling to prevent this? How can I prevent this pattern from even being able to happen in the first place?
At the velocity that you want to go, a human can't be tasked with finding every single code smell. And you wouldn't want to do it even if you had infinite time. You need to stop slop in CI. Slop is a repository problem. It's an ecosystem problem. It's a static analysis and CI problem. It's a you problem.
Take a Hard Look At Your Ecosystem#
Is it ripe for AI? Does it have linters, formatters, and other tooling that is flexible enough to enforce great code? Can you, on a whim, codify a new lint rule to prevent agents from writing certain patterns or importing from certain modules? I'm serious. This is how you prevent slop. This is a question only you can answer. But there is a reason languages like TypeScript and Rust are so popular for agentic software development.