Devs Wrote Slop Code Long Before AI Did

Level 1: The Messy Room Defense

A kid's room has been a disaster zone for years — clothes on the floor, toys everywhere. Then the family gets a robot helper, the robot leaves a few toys out, and suddenly the kid is outraged: "Look at the mess this robot makes!" The grown-up in the doorway just raises an eyebrow, because everyone remembers what the room looked like last month. The joke is about pointing fingers at the new arrival for a mess we made ourselves — it's funny because deep down, everybody knows whose socks those are.

Level 2: What "Slop" Actually Means

Vocabulary for the debate this tweet is wading into:

• Slop code: code that works (mostly) but is sloppy — duplicated logic, no tests, misleading names, error handling that consists of catch (e) {}. The term AI slop originally described low-effort AI-generated articles and images, then migrated to code as assistants like Copilot-style tools became standard.
• LLM coding assistants: AI tools that suggest or write code from natural-language prompts. Their output is statistically plausible, which is exactly why subtle wrongness slips through review.
• Code review: the human checkpoint meant to catch slop. The dirty secret referenced here is that reviews were often rubber stamps ("LGTM") long before AI — so the safety net people claim AI is bypassing was already full of holes.
• Hot take: a deliberately provocative one-liner. The tweet's format — large text, zero hedging — is engineered for the quote-tweet wars it obviously started.

The early-career takeaway: when you inherit a horrifying legacy file, run git blame before assuming an AI did it. Odds are excellent it was a human in 2014 with a deadline. The lesson isn't "quality doesn't matter"; it's that quality has always been a process problem, and tools just change the speed at which the process fails.

Level 3: Git Blame Has Receipts

One sentence from Arvid Kahl (@arvidkahl), verified account, Subscribe button and all:

Devs are acting like they didn't write slop code before AI.

That's the whole image, and it's a precision strike on the most self-flattering narrative in the current AI slop discourse. The prevailing complaint goes: LLM coding assistants flood codebases with plausible-looking, barely-understood, unreviewed code, degrading craft that was previously upheld by diligent artisans. Kahl's counter is the git log. The industry that now clutches its pearls about machine-generated mediocrity is the same industry that built its foundations on copy-paste from Stack Overflow (famously including the accepted answer's bugs), // TODO: fix this properly comments old enough to vote, 4,000-line God classes, and entire production systems whose architecture document is the phrase "it grew organically." Technical debt wasn't invented in 2023; Ward Cunningham coined the metaphor in 1992 because the problem was already universal.

What makes the take sting rather than merely snark is the kernel of mechanism underneath it. Slop has always been an incentive output, not a tooling output. Deadlines, demo-driven development, "we'll refactor after launch" (narrator: they did not), promotion cycles that reward shipped features over deleted lines — these produced human slop at scale long before a transformer ever autocompleted a for-loop. The honest version of the AI critique isn't "machines write slop and we didn't"; it's "machines removed the rate limiter." A tired human could only produce so much questionable code per day. An LLM produces it at tokens-per-second, with confident docstrings. Same failure mode, industrialized throughput — which is arguably more alarming, but you can't get there while pretending the baseline was clean.

There's also a quieter jab at DevCommunities dynamics: identity-protective memory. Craftsmanship discourse spikes precisely when a new tool threatens status. The senior who learned by shipping horrors now frames the horrors as a rite of passage, while the same output from a model is contamination. Kahl, a bootstrapper who has audibly shipped pragmatic code to pay rent, is puncturing that selective memory from inside the building.