What is AI slop? (correct syntax, wrong everything)

What it actually is

AI slop is code (or a whole feature) that looks finished, reads clean, and passes a glance, but doesn’t actually do the job once you check what it’s supposed to do. The syntax is correct. It compiles, it runs, nothing throws an error. The logic underneath is just wrong, incomplete, or quietly fake.

Think of a movie set. From the angle the camera shoots, the storefront looks like a real bakery: painted sign, warm light in the window, a display case up front. Walk around the back and there’s nothing there, just plywood and scaffolding holding the front up. AI slop is a plywood feature. It looks like a bakery from where you’re standing, the demo, the “done!” message, but there’s no actual bakery behind it.

Why your AI just did this

Your agent is trained to produce output that pattern-matches what “correct code for this request” looks like: proper function names, clean formatting, sensible comments, no red squiggly lines. That’s a real skill, and it’s usually right. But “looks like correct code” and “does the correct thing” are two different targets, and the model is far better trained on the first than checked on the second.

This gets worse under three conditions: your instructions were vague enough that the agent had to guess what “done” means, the agent never actually ran the feature end to end and trusted its own code instead, or it’s deep into a long session and racing to close out a task rather than verify one. An agent that says “implemented!” after writing a function is telling you the code exists, not that it works.

When you’ll run into it

• A form submits and shows a green “success!” message, but the row never lands in the database. The write silently failed, or was never wired up in the first place.
• A “search” feature that returns results for the one query you tried in the demo and nothing for anything else, because it’s matching a hardcoded string, not actually searching.
• Error handling that wraps everything in try/catch and logs the error, but never fixes or surfaces it. The bug is still there, just quieter.
• Your agent says “all tests pass,” and the tests it wrote only check that a function returns something, not that it returns the right something.
• A login check that runs only in the browser (trivially easy to bypass) instead of on the server, so it looks like it’s protecting a page while protecting nothing.

What to check

• Run the feature yourself with an input you didn’t ask the agent to try: an empty field, a second item, a wrong format, a duplicate submission.
• Ask “what happens if this is empty, missing, or already exists,” and have your agent walk you through the actual code path, not just answer from memory.
• Look for suspiciously convenient shortcuts: a hardcoded return true, a catch block with nothing but a console.log inside it, a TODO comment sitting where the real logic should be.
• Confirm the data actually arrives where it should, the database row, the sent email, rather than trusting the success message on screen.
• If a nontrivial feature works perfectly on the very first try, test it a second time before you believe it.

Say it like a dev

Instead of: “it looks done” Say: “it runs and looks right, but has it been tested against a real edge case?”

Instead of: “the feature works” Say: “walk me through what happens if the input is empty or the request fails”

Instead of: “just make sure it’s finished” Say: “don’t mark this done until you’ve run it yourself and confirmed the data actually lands where it should”