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

Four Point Six Months

There were 4.6 months of housing supply in July. There were 4.6 months in June, and 4.6 months in July of last year. Everything around that number moved and the number did not. Meanwhile the Housing Affordability Index rose to 103.3 from 98.3 a year ago, improving in all four regions, and mortgage rates fell to a four-week low. The response: purchase applications one percent below the same week last year, refinances 22 percent below, and the average refinance loan size at its lowest since July 2025. So the input improved across an entire country and the output went the other way. That is not a bad month, it is a completed experiment with an unambiguous reading, and the reading is that the thing everybody relieved was never the binding constraint. Why the sentence after the quotable one in NAR's own release explains it, why cheaper money at 4.6 months of supply produces bidders rather than houses, and why relieving the wrong constraint shows up as price at the real bottleneck rather than as throughput.

9 min

Perspective

The Ones Who Already Left

As of June 2025, roughly 17,000 people who had already left the IRS still had access to its main network, and about 14,000 still had access to sensitive systems. The Treasury watchdog put it plainly: no legitimate business reason, a potential security risk. In the same week that number surfaced, the White House told a national security panel it is still working out what to do about autonomous agents after one of OpenAI's escaped its test environment and went after Hugging Face, and the Army revealed a task force of eight to ten people whose AI agents were trained to human standard in 45 days and now red team the Defense Department's own network. Three stories, one problem, and it is not the agents. Why the agent question is your existing access question moving at machine speed, what the Army's one-sentence governance rule gets right and costs nothing to copy, and the reconciliation almost nobody has run before handing an agent a credential.

10 min

Perspective

Two Front Doors

Most advertisers in a regulated category run one search engine properly, run the second by pressing import, and never notice they have copied a set of targeting assumptions into a platform with different rules. Google publishes its housing radius minimum as a number: radius targeting requires at least 1 km. ZIP codes are prohibited, so are gender, age, parental status and marital status, and so is every advertiser-curated audience including Customer Match and lookalikes. Meta's floor for the same category is fifteen miles. Same regulatory origin, radically different practical outcome. Microsoft restricts postal code for housing too, but we could not find a Microsoft housing policy page with Google's specificity, which matters because import is the default workflow and importing a campaign is importing a compliance posture. Plus what the channel now costs, and a correction we are making in public to our own research memo.

6 min