AI Slop is an Effort Problem

The internet is currently drowning in synthetic noise, and the tech world has found its favorite new dirty word: slop.

Step onto Reddit or Hacker News and you'll see blanket bans on anything touched by a language model. Maintainers are exhausted, yelling at users to take their AI-generated pull requests elsewhere. Recent open-source incidents — like the Godot engine community getting swamped with automated PRs that fix entirely hallucinated issues — show that the friction is real.

The current backlash has misdiagnosed the disease. The crisis isn't that AI makes software bad. The crisis is that AI made low effort cheap.

The industry has entered a phase of knee-jerk Luddite elitism — a form of syntactical gatekeeping born out of pure attention exhaustion. Drowning in information, developers are looking for the fastest way to filter the noise. If they see a sign of AI assistance, they yell "get a horse!" and dismiss it out of hand. They assume that because a tool can be used lazily, it is being used lazily.

They are missing the rise of the Solo Architect who uses intentional iteration to out-ship entire teams.

The vacuum of "vibe coding"

There is a segment of the developer population doing what the industry calls vibe coding. They spin up ten agents, let them crank blindly, and brag about the volume of tokens they consumed. That isn't engineering; it's a vanity metric. If a feature is simple, a single prompt might work. If it's complicated, it gets out of hand instantly, the operator gets overwhelmed, and they move on — leaving synthetic exhaust in their wake.

When you copy-paste a single prompt, get a single output, and ship it without a feedback loop — that is slop. It's the software equivalent of human slop: lazy, unvetted, thoughtless.

Early in my career, when I helped launch the very first Splunk Live as a technical evangelist (or what the industry now calls a developer advocate), I spent my time with eyes on everything: product management, revenue, sales, and exactly how customers were breaking our software.

We were getting ready to go public, and our CEO, Michael Baum, had a massive invoice from a giant tech corporation framed directly on his office wall. It was a full refund. He hung it there to remind us every day of a brutal reality: moving fast doesn't matter if the software sucks under real-world conditions.

During a tense, twelve-person meeting filled with raging front-end designers, architects, and icon illustrators arguing over how to fix shipping friction, I asked a simple question: "When was the last time we did a usability study?"

The entire room went dead silent. Everyone looked at the floor. Finally a UI designer admitted, "We've never done one." They were dogfooding their own product heavily, but they had never actually watched an outsider interact with it. They were building in a vacuum.

The slop generators are doing the exact same thing today. They hit a button, generate 300 lines of syntax, and throw it over the fence without ever sitting down to aggressively use, break, and live in what they just built.

The annealing loop

A seasoned architect doesn't build in a vacuum. They use a discipline called annealing.

Annealing is the metallurgy process of heating metal, banging on it to shape it, cooling it quickly, then heating it again to remove internal stresses. In high-leverage software engineering, the workflow follows the same cycle:

1. The spec. You set strict architectural boundaries. You don't ask the model to write "a feature"; you ask it to write a specific modular function inside a container you already designed.
2. The forge. The model accelerates the typing, spinning up a high-velocity draft.
3. The usability study. You break the vacuum. You ruthlessly dogfood the code. You force the AI to wire up deep telemetry — logging client errors back to the server, recording every failure mode — so you have immediate, objective visibility into where it fails.
4. The reforge. You take those real-world errors, feed them back into the spec, split the files that grew too bloated, centralize duplicated strings, and put the screws to the code.

You run this loop four, five, six times. By the time it hits production, the resulting software isn't synthetic luck. It's an artisan craft — tight, modular, heavily audited.

The leverage of the modular ratchet

Critics claim that if you spend all this time writing specs, building feedback loops, and running refinement cycles, you aren't actually saving time. They are completely wrong. They are ignoring the ratchet mechanism of architectural leverage.

Think of it like 3D printing. If you have one printer, you can only print so fast. If you have an array of machines running a highly refined design spec, you scale your output beyond normal human limits.

When we built Hyperia, instead of spending three months manually combing through every line of the upstream Hyper terminal codebase just to figure out how to extend it, the model ingested and mapped the architecture instantly. The 15% of boilerplate code that everyone has already written a thousand times was handled.

Do we need our eyes on 100% of the underlying library syntax? No. No more than a Rust developer needs to manually audit every line of an open-source crate they import. You manage the boundaries, and you verify the behavior.

Intentional attention

Software is buggy by nature. Ever since Grace Hopper pulled a literal moth out of a relay, humans have been shipping bugs. Recent metrics show code churn spiking on teams that use AI carelessly — GitClear reports duplication up roughly 8× and refactoring collapsed by more than 60% since AI tools went ubiquitous — but that isn't a failure of the intelligence. It's a failure of attention. One of the biggest risks in traditional development has always been when a contributor steps into a massive, complicated codebase they don't fully understand, alters a line, and introduces a critical architectural flaw.

A model, when driven by a skilled architect, can actually make a passable effort to understand the global architecture before it touches a line. The difference lies entirely in attention.

A few days ago, I rode in a Lyft where the driver spent the entire trip raging about automation, yelling that AI would never be able to safely drive a car. He was talking so much, completely distracted, that he almost rear-ended the car in front of him.

Immediately afterward, I got into a Tesla running full autonomy. For twenty minutes, it drove us flawlessly down the road. It was spectacular. It didn't get distracted by conversation. It didn't have an ego. It was watching the road with intent attention, constantly compensating for the bad human drivers around it.

If you set the attention of the AI correctly — by constraining it with a strict architectural spec and binding it to a real-world testing loop — it will produce exceptional outcomes. The second you take your own eyes off the system and let its attention drift, that's where the slop creeps in.

The artisan shift

We aren't looking at a crisis of machine intelligence. We are looking at a separation of human capability.

The first Teslas off the line had massive production issues. Early printing presses produced messy ink smudges. The direction of travel was obvious to anyone paying attention.

The developers sitting on forums writing blanket bans on AI content are the modern equivalent of carriage drivers yelling "get a horse!" They are terrified because their core economic value — acting as a human compiler who translates Jira tickets into basic boilerplate — is evaporating.

The future doesn't belong to the loudest gatekeepers, nor to the lazy prompt-monkeys. The future belongs to the Solo Architects who treat the model like a high-powered forge — burning away low-effort slop through relentless, intentional, real-world iteration.

How we build

Every service in the fleet — Hyperia, Nemesis 8, Ferricula, Grub — was designed by humans, the architecture decided by humans, the security boundaries chosen by humans, and the code reviewed line-by-line by humans. AI is in the loop — heavily — but it is in the loop the way a junior on a senior team is in the loop: producing drafts, getting torn apart, learning the codebase by being told what's wrong with what it just wrote.

That discipline is the only thing that separates an artisan from a slop generator. Annealing isn't slow. It's the only thing that's fast enough.

Built and shipped by Deep Blue Dynamics. Reach Kord at kord@deepbluedynamics.com.

// transmission ends