The short answer
AI slop is AI output made in bulk and without care: text, images, video or code that looks finished at first glance and turns out to help nobody. Slop literally means pig feed, the scraps you tip into a trough. The term is about how something was made. A model generates it, nobody reads it, and it goes straight out into the world.
The same models do excellent work when someone gives them context, checks the result and signs off on it. Slop appears wherever that person is missing.
Where you run into AI slop
The term took off with the flood of AI content on social media and in search results, and by now slop shows up anywhere AI makes something.
Text
Blog posts, LinkedIn updates and product copy with the same opening lines, empty superlatives and paragraphs that say a lot without claiming anything. The topic is often well chosen, and everything only a practitioner would know is missing.
Images and video
Generated photos with six fingers, unreadable text on signs and a glossy look you start recognising everywhere after a few times. Whole social media accounts are filled with images like these.
Code
Functions that exist three times, error handling that hides errors and imports of packages that don't exist. The app works in the demo, and nobody can explain how.
In text and images, slop is mostly annoying. In code it is riskier, because the bad part stays invisible until something breaks.
AI slop in code
Code slop is harder to spot than a text full of clichés, because the code usually does what it should. A user sees a working screen. What sits underneath is only visible to someone who reads the code. These are the signals we run into most often when we review AI-generated code:
The same logic in five places
A model doesn't see the whole codebase. It writes a new helper while one already exists, and a few months later the same calculation lives in five places, each slightly different. Change one and the rest stop matching.
Error handling that hides errors
A try/catch wrapped around everything that logs the error and carries on. The screen never crashes, which is exactly why you find out weeks later that orders were only half saved.
Invented packages and functions
An import of a library that doesn't exist, or a method that only existed in an older version. Sometimes the build fails. Sometimes someone installs a package with that name that a stranger registered.
Comments that retell the code
A sentence above every line repeating what the line does. The reasoning is what's missing: why this choice, and what breaks if you change it.
Tests that test nothing
Tests that always pass because they only check that a function returns something. Coverage looks high and catches no bugs at all.
Huge changes in one go
A two-thousand-line pull request where a small fix and half a rebuild are mixed together. Nobody can review that seriously, so it gets approved without anyone having read it.
Slop code works in the demo. The trouble is in everything the demo doesn’t show: edge cases, errors, security and the next change.
Why AI slop happens
A language model predicts the most likely answer. Without extra information, that is the average of everything it has ever seen, and the average is exactly what feels generic. Three things turn a useful model into a slop machine:
Too little context
The model knows nothing about your audience, your codebase or your conventions. So it fills the gaps with whatever usually fits.
Nobody reads it
When output is published or merged straight away, nobody catches the mistakes. The faster you generate, the bigger that pile of unread work gets.
Regenerating until it looks right
Not happy? Generate again. That throws away the good parts too, and the model learns nothing about what was wrong.
We tested how much the process matters with text in our experiment against AI slop: the same model wrote clearly better with structured input and targeted feedback than with a loose prompt and a regenerate button.
AI slop or good AI work?
The difference lies in what happens before and after generating, rarely in the model.
| AI slop | Good AI work | |
|---|---|---|
| Input | A short prompt with no context. | A clear brief with examples, conventions and the existing code or text attached. |
| Checking | Does it run? Then it's done. | Someone reads the result and can explain why it's right. |
| Size | Generate as much as possible at once. | Small steps you can judge one at a time. |
| Mistakes | Regenerate until it looks fine. | Name what's wrong and have exactly that changed. |
| Owner | Nobody, the AI made it. | A person who signs off on it. |
How to keep AI slop out of your own code
You can prevent slop with AI firmly in your team. The work around it makes the difference.
Give the model the context
Show the AI the existing code, your conventions and the task before it starts. A short spec up front stops the model from guessing what you mean.
Work in small steps
One change at a time, small enough to read in a few minutes. A diff you can't take in is a diff you can't approve.
Read every line that goes live
Someone who can read code reviews what the model wrote: does it work, does it fit the rest, and what happens when it fails?
Let tests pin down the behaviour
Tests that mimic real situations, bad input included. They catch the change that breaks something else before a customer does.
How a spec up front changes the outcome is covered in spec-driven development vs vibe coding. If you already have an app largely written by AI, how to make a vibe-coded app production-ready shows how to harden it.
Conclusion: slop is a choice in the process
AI slop is what’s left when you let AI generate and skip everything else. You recognise it by generic language, repetition and details that don’t add up, and in code by duplicated logic, hidden errors and changes nobody read. With context up front, small steps and a person who reads the result, the same model produces work you can build on.
What is AI slop?
What does slop mean?
How do you spot AI slop in code?
Is all AI-generated code slop?
How do you prevent AI slop?
Is AI slop dangerous?
How much slop is in your codebase?
A senior developer reads your AI-generated code, points out where the risk is and tells you what to fix first.
