You already know AI slop. It is the listicle nobody wrote, the product photo with six fingers, the comment section that agrees with everything. The internet's signal-to-noise ratio has been paying the price of free content generation for two years.
Now the same economics have arrived in software development. Code generation is effectively free, and every engineering org is about to learn the lesson the content industry learned the hard way: when production costs collapse, the bottleneck does not disappear. It moves to quality control / and most teams have not moved it.
What slop looks like in a codebase
Content slop is easy to spot because you are the consumer. Code slop is harder, because it compiles, the tests pass, and the demo works. It fails later, quietly, and at interest.
Plausible-but-wrong code. AI-generated code fails differently than human code. A human writes bugs that look like bugs. A model writes bugs that look like working code: the right shape, the right naming, confident comments / and a subtly wrong condition, a race it never considered, an edge case it invented its way around. The failure mode is not "broken." It is "convincing."
Volume as a substitute for design. A model asked for a feature produces a feature, plus three helper classes, a utility module, defensive checks for conditions that cannot occur, and a configuration system nobody requested. Every generated line looks professional. Collectively they are landfill: code that must now be read, maintained, secured, and paid for, forever, without having earned its place.
Duplication at machine speed. An agent does not know your codebase already has a date formatter, a retry wrapper, and a perfectly good pagination helper. So it writes new ones. Every session, every time. Human copy-paste debt accumulated over years; AI duplication accumulates over afternoons. The codebase stops having one way to do things, and a codebase with nine ways to do one thing has zero ways to change it safely.
Hallucinated dependencies. Models invent package names that sound real, and attackers have noticed: register the hallucinated name, fill it with malware, and wait for the next agent to install it. The supply-chain attack of the slop era does not have to compromise anything / it just has to publish a package with a plausible name and wait.
Tests that test nothing. Ask a model for tests and you get tests: green, numerous, and asserting that the code does what the code does. Coverage goes up. Confidence should not. A test suite generated from the implementation is a mirror, not a gate / it will happily confirm every bug the implementation contains.
Review theater at scale. The pull request that used to be 40 lines is now 900. Reviewers face a wall of plausible-looking diff produced in minutes, and they do the human thing: skim, approve, move on. The team still has a review process. It just no longer reviews anything. Slop's greatest trick is exhausting the immune system meant to catch it.
The velocity illusion. Tickets close faster than ever. Output charts point up and to the right. Meanwhile incidents creep up, onboarding slows down because nobody understands the code, and every change takes longer than the last one because the codebase is now mostly sediment. Output is not outcome / and slop optimizes output exclusively.
Why this happens to good teams
None of this requires a bad engineer. It requires a normal team under normal deadline pressure, handed a tool that produces infinite plausible material, inside a process that was sized for human throughput. The review gate, the test suite, the architecture discipline / all of it was implicitly calibrated to "code arrives slowly and a human thought about it." Remove that assumption and every safeguard is suddenly under-provisioned.
The deeper trap is accountability diffusion. When a person writes bad code, ownership is clear. When an agent writes it, everyone feels slightly less responsible: the developer "just prompted it," the reviewer "assumed the developer checked," and six months later the answer to "who understands this module?" is nobody / it arrived pre-written, was skimmed once, and has been load-bearing ever since.
How to keep the slop out
Make ownership non-negotiable. One rule does more than any tool: the engineer who ships it owns it, entirely. "The AI wrote it" is not a defense any more than "Stack Overflow wrote it" was. If you cannot explain the diff, you cannot merge the diff. This single norm re-attaches a human brain to every line that enters the codebase.
Spec before generation. Slop is what you get when the model decides the shape of the work. Decide it yourself: the interface, the constraints, what already exists to reuse, what is out of scope. A tight brief turns an agent from a landfill generator into precision labor. This is the same lesson every discipline learns about AI / garbage brief, infinite garbage.
Keep diffs small on purpose. The agent can produce 900 lines at once. Do not let it. Scope work so changes arrive in reviewable units, because your real constraint is no longer generation speed / it is review bandwidth, and a gate that cannot hold traffic is not a gate.
Write acceptance tests before the code exists. Tests written from the spec, by a human or at minimum reviewed like production code, are the contract. Tests generated after the fact from the implementation are decoration. If the machine writes the code, the humans must own the definition of correct.
Automate the janitorial gate. Linters, static analysis, dependency allow-lists, duplication detectors, security scanning / wired into CI, not into good intentions. Machines generating code at machine speed must be checked by machines at machine speed; humans should spend their attention on design and correctness, not formatting and known-bad patterns.
Verify dependencies like an adult. Every new package an agent introduces gets checked: does it exist, is it the real one, is it maintained, do we already have something that does this? Hallucinated and typosquatted packages are now an attack surface. Treat "the model suggested it" as zero evidence.
Feed the agent your conventions. Most duplication and drift happens because the model cannot see your standards. Put them where it can: project instruction files, documented patterns, named examples of "this is how we do it here." An agent with your conventions in context stops inventing rival ones.
Budget for demolition. Some slop will get through / plan for it. A standing refactor allocation, dead-code sweeps, duplication audits. Cheap generation means the codebase grows faster than ever, which means gardening is no longer optional hygiene. It is the job.
Measure outcomes, not output. Retire velocity worship before it retires you. Track incident rates, change failure rate, time-to-understand, review depth. The teams that survive the slop era will be the ones whose metrics can tell the difference between shipping and dumping.
Our position
We use AI agents in development every day, at volume, and we would not go back. Used with discipline, they are the best thing to happen to delivery speed in a generation. That is exactly why we take slop seriously: the tool is not the problem. The missing operating system around the tool is.
The content industry's slop lesson took two years and cost it its credibility. Software gets to choose whether to repeat that / or to notice that every defense it needs already exists: specs, small diffs, real tests, hard gates, human ownership. None of it is new. It just stopped being optional.
AI did not lower the bar for software quality. It lowered the cost of producing things that look like they cleared it. The bar is now yours to hold.