BMAD Founder Brian Madison on Slop, Specs, and AI

The slop apocalypse Brian Madison is worried about won't announce itself with a production outage. No alerts firing at 3am, no postmortem, no dramatic root cause analysis. It'll be quieter than that: a comment that describes what the function used to do, a refactor that never happened because the agent shipped something that technically worked, a codebase that slowly becomes more expensive and slower to work with every sprint. Death by a thousand tokens.

Madison is the founder of BMAD, one of the more prominent AI coding frameworks in the agentic development space, and in a recent community session hosted by Cole Medin he laid out a view of AI coding's trajectory that's worth sitting with—not because it's contrarian, but because it's specific in ways that most takes in this space aren't.

The problem isn't broken code

Madison's canonical example: Anthropic's Claude Opus 5 developed a habit of inserting verbose code comments everywhere. Not catastrophically. The code still ran. Code review tooling mostly missed it. Engineers, moving fast, let it slide. But Madison sees this as a slow-acting poison. When comments drift out of sync with what the code actually does—which they will, because agents keep iterating while comments stay frozen—you get what he calls "attention deficiencies" in the model. The LLM starts fighting itself over which source of truth to believe: the comment or the implementation.

"It might not manifest in broken code," he said. "It might not manifest in the agent not being able to implement. But what it will manifest is more token spend and just more cycles and things will slow down."

That's a more useful failure mode than most people are tracking. The thing that kills AI-assisted codebases won't be a spectacular meltdown—it'll be gradual compounding. The best models are hitting 90% on coding benchmarks, Madison notes, and still producing slop that accumulates. Slop that nobody goes back to clean up because the sprint already moved on.

This connects to something Dexter Horthy documented more viscerally: a fully automated software factory that corrupted its own codebase precisely because there was no one watching for drift. Madison's version of the problem is slower and more insidious, but the mechanism is similar—agent output, left unreviewed and unrefactored, compounds into something worse than what you started with.

"Human on the loop" vs. the dark factory fantasy

The AI coding discourse has a seductive endpoint that keeps circulating: the "dark factory," a fully automated pipeline where you feed in a spec and get shipped code out the other end, no humans required. Madison pushed back on this—carefully, and in a way that's more interesting than a flat rejection.

"Spec in, shipped code out" is already essentially possible at the individual level, he acknowledged. But he's not convinced that's the goal to optimize for. His preferred frame is "human on the loop"—not in the loop, managing every step, but on it, maintaining oversight and judgment from a higher altitude. The distinction matters: a human in the loop becomes a bottleneck; a human on the loop stays in control without becoming the constraint.

"I personally build BMAD around the idea of you are in control," Madison said. "The agent is guiding you through it, using it as a partner."

The dark factory, taken to its logical end, also automating the left side of the pipeline—deciding what to build, talking to customers, understanding market fit—is where Madison draws the line. Not because it's technically impossible, but because "I don't think we want to in every case." The value that humans bring to software development increasingly concentrates in the work before the coding starts: understanding the business, crafting the spec, asking whether this thing should exist at all. The agent can write the code. It can't tell you what the code should do.

The spec is the work

This is the part of BMAD's philosophy that tends to get underappreciated relative to its technical machinery. Madison is building toward V7, which adds proper multi-file epic/story structures to support team collaboration—splitting work into separate folders, connecting to systems like Azure DevOps or Linear, making it possible for product managers, designers, and engineers to collaborate on planning artifacts without everyone needing to be fluent in Git. That's table-stakes enterprise stuff, and it's a sensible direction.

But the more interesting argument is about where the real leverage is. Madison talks about an "inflection point" in AI adoption at the team level: you speed up your engineers, they start shipping faster, and suddenly the bottleneck isn't implementation—it's everything upstream. The business can't define requirements fast enough. Product managers become the constraint. The spec quality becomes the limiting factor on how good the final product is, because the downstream automation is getting better at executing whatever it's given, good or bad.

"If you have a good quality consistent spec," Madison said, "it very soon is going to be to the point where you're doing something in Jira, you're going to drag that ticket to some process, an agent's going to pick it up, start doing it, and you're going to be reviewing a code review."

Garbage in, garbage out at scale. The engineering discipline that actually matters is AI coding agents need structure, not just velocity—and structure starts with a spec that's worth executing against. This is why Madison is more interested in the left side of the pipeline than the right: the ideation, the research, the "should we even be building this" conversation that BMAD tries to facilitate through tools like its PRFAC workflow (borrowed from Amazon's press-release-first approach to product development).

Systems thinkers and the identity crisis of "good engineers"

The talent conversation Madison and Medin had is genuinely uncomfortable, and worth engaging with honestly rather than softening.

The developers most at risk right now, according to Madison, aren't the weakest—they're a specific kind of strong. The engineer who could fire through a ticket without touching Stack Overflow, who had Python or TypeScript syntax as a kind of professional identity, who was the person the team turned to for quick scripts. AI has made that skill set dramatically less scarce overnight. The people thriving are the ones who can think at the level of systems—who understand what the product needs to be, why the architecture should work a certain way, when a design pattern is appropriate versus cargo-culted.

Madison calls this "taste." He's careful to frame it as developable rather than innate, which is the right call—but he's also honest that some engineers are finding this transition painful and some aren't, and the difference tracks to how comfortable they are leaving the weeds.

What he doesn't have a clean answer to, and neither does anyone else right now, is what this means for engineers just entering the field. Madison expressed genuine unease about what universities are teaching—and some bemusement at hearing that BMAD was being taught as "vibe coding 101" somewhere. He hopes design patterns are still on the syllabus. The argument for keeping them there is basically his slop apocalypse argument in reverse: you need taste to recognize when the agent has produced something that'll compound badly, and taste requires having internalized what good looks like.

The model volatility problem nobody's pricing in

One thread that ran through the whole conversation: the instability of the foundation everyone's building on. Claude Opus 5's comment-insertion behavior emerged from Anthropic stripping roughly 80% of their system prompt, according to Madison. Enterprises locked into a single provider suddenly find themselves at the mercy of decisions made in San Francisco last Tuesday. BMAD's deliberate choice not to be Claude-specific, and to write skills that work across model families, looks less like hedging and more like basic risk management when you frame it this way.

"When have we ever had a software product we pay for that randomly changes this drastically on a daily basis?" Madison asked—and it's a fair question. Most companies have run happily on single-cloud infrastructure for two decades. Single-model AI coding stacks are already proving less stable than that.

Madison's V7 announcement—skills landing in Vercel's NPX marketplace and the Claude and Codex ecosystems, modular skill bundles for different personas and workflows—suggests BMAD is trying to build something that survives those changes rather than chasing any particular model's capabilities. Whether that bet pays off depends on how volatile the next few model releases are. Given recent history, AI coding tools remain a moving target that rewards frameworks with staying power over those that optimize for the current best model.

The slop apocalypse isn't dramatic. It's the sum of a thousand small decisions to not look at the code, not refactor after the epic closes, not think hard about whether the comment still describes the function. Madison's read is that the teams who survive it are the ones who kept humans close enough to the process to catch the drift before it compounds into something unfixable.

Dev Kapoor covers open source software and developer communities for Buzzrag.