Independent newsroom The Wyre News Network OpEd desk

Perspective 6 min read

AI Slop Moves to Development

The internet drowned in AI content, and now the same flood is heading for your codebase. Code slop compiles, passes its own tests, and demos beautifully / then fails quietly, at interest. Where the pitfalls happen, why they happen to good teams, and the gates that keep the landfill out.

By Brian Pandorf for the Wyre OpEd desk

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.

Related Reading

More Opinion

From the same desk

Perspective

A Rounding Error

Over twenty-four hours the single largest AI crawler on one consultant's website arrived roughly 1,500 times under a nonprofit research archive's name, sent back nothing, and asked for his SSH keys, his AWS config and his Firebase service account key. Across a hundred such paths: 1,028 requests, 6.7 megabytes, zero referrals, and requests for anything he had actually written rounding to nothing. It appeared in no security log, because security logs record rule trips and he was not blocking it. It appeared in exactly one place: the AI crawler dashboard, counted as an audience. Cloudflare's CFO says humans will be a rounding error on the internet within five years and admits he has been wrong every time, always low. Machine traffic passed human traffic in May 2026, two years earlier than the company forecast. Why robots.txt is a request that OpenAI's own documentation says may not apply, why blocking the obvious way costs you the visibility and keeps the fetches, what it means that agent config files are now on the standard secret-scanning wordlist, and the afternoon of work almost no company has done.

13 min

Perspective

Cut The Price Last

When demand softens, the first lever everybody reaches for is price. It is also the most expensive lever on the board, the hardest to reverse, and almost never the one that was actually broken. Redfin reports buyers have negotiating power across most of the country, the median housing payment fell to $2,575 because sellers cut asking prices to a one-year low, and pending sales hit their lowest since early April. Underneath it, July payrolls came in at minus 23,000 against an expected plus 83,000 with another 103,000 revised away. So the softening is real, and the question is which lever you pull and in what order. Why cutting price assumes a diagnosis you have usually not earned, the cheaper levers ranked, why the gap between the decision and the execution is where the margin leaks, and the measurement problem underneath all of it: cost per lead holds beautifully steady while cost per closed sale doubles.

6 min

Perspective

The Layer Nobody Looks At

A man in Connecticut typed instructions into his own court filing in three-point white text on a white background, where no judge would see them and any software would. They told the system to agree with him and to disregard the court's earlier denials. He was caught, warned, did it again, and lost his e-filing privileges. In the same seven days Google made the visible watermark on its AI images optional while keeping the invisible one, Anthropic shipped an API letting third parties detect text its models probably wrote, a new benchmark found that no frontier model clears sixty percent on basic visual perception with counting, localization and OCR among the weakest skills, and OpenAI started turning Mac users' clicks and keystrokes into a searchable memory their assistant can read, while warning in its own documentation about prompt injection. Five stories, one story. Every document, image and screen you produce now has two readers and they do not see the same thing. What the judge worked out on his own about where these attacks get caught, why provenance just moved into the layer humans cannot check, what a watermark hit actually proves and why a clean result proves nothing at all, and the ten-line diff almost nobody runs.

18 min