SlopBurn: The World's First Vibecoding QA Roguelike RPG

What if debugging, hardening, and verification felt less like cleanup and more like dungeon descent?

As many people have noted, vibecoding has breathed new AI life into the tried-and-true Unix-style CLI. I am fond of saying that AI UXes are moving slower than we might expect because communicating AI capabilities to users in an intuitive way is really freaking hard. So AI systems bootstrap from the most familiar UXes, and those familiar UXes end up exerting an unusual gravitational pull.

Games are powerful metaphors. Many of the game metaphors being applied to agentic software development read like management sims: move your Sims around the simulation with breadth-first parallelism, modularity, and perfect information.

I want to present a competing game metaphor for agentic software development:

• depth first over breadth first, to reflect the level of technical debt left behind by agentic coding today
• path dependence, to reflect the increased role of context and previous decisions in software engineering
• imperfect information and progressive discovery, to reflect the role of emergent user expectations

Depth-first, path-dependent, imperfect-information, text-based games are not a new genre. Gary Gygax first developed D&D for the tabletop fifty years ago. MUDs came to PLATO and then Unix systems shortly after, increasingly inspired by D&D.

So I sought to leverage D&D-style UX metaphors for a refactor and reskin of the Cutline QA Engineering MCP Server. Use the structure and narrative conventions of a D&D game to, well, trick users into enjoying debugging and securing their vibeware with the same delight they felt while creating it. Also give users a ready vocabulary of metaphors for the unfamiliar aspects of vibe debugging and vibe hardening as they navigate the dungeons of their technical debt.

That is the core metaphor behind SlopBurn: a complete agentic engineering system is not about fanning out in massive parallelism. It is about iterative, depth-first exploration of the structures you have summoned.

The structure of post-MVP vibecoding is simply like a roguelike RPG:

• it is text-driven
• it is iterative
• it rewards judgment under uncertainty
• it punishes shallow greed
• it turns tiny decisions into cascading consequences

And, most importantly, it is not really about moving broadly across the map. It is about choosing where to descend, what to engage, and how to survive contact with complexity.

SlopBurn takes that metaphor seriously and turns it into an interface for software quality.

Vibecoding As Dungeon Descent

Most of the time, AI coding tools present software work as a flat surface. You ask for something, the model gives you something back, and the interaction repeats.

But that is not what the work actually feels like.

What it actually feels like is descent. You enter a system. You find signals of danger. You try to identify the active threat. You inspect weakpoints. You prepare an attack. You commit code. You run tests. You survive or you do not. Then you decide whether to push deeper or retreat to regroup.

That is a roguelike loop.

And once you see vibecoding that way, a lot of design choices become obvious. Bugs are monsters. Test obligations are weakpoints. Verification is combat. Rooms and routes represent different kinds of engineering pressure. Recovery, progression, and build identity all become meaningful instead of decorative.

The metaphor stops being skin-deep and starts becoming a better map of the work itself.

That is what SlopBurn is trying to do: not gamify coding from the outside, but reveal the game structure that is already there.

Why Quality Belongs At The Center

If vibecoding is a dungeon, then software quality is what determines whether the run is real or fake.

Anyone can generate code. The hard part is knowing whether the system still holds. The hard part is discovering what is actually fragile, what proof counts, what regressions are still alive, and what kind of move the current room justifies.

That is why SlopBurn is a QA roguelike RPG, not just a coding game.

It is built around the idea that quality work should be the main loop, not an afterthought. You are not just summoning code out of a language model. You are scouting, testing, verifying, hardening, and clearing chambers in a living system.

The point is not output volume.

The point is whether you can descend into a codebase and come back with stronger guarantees.

Depth-First, Not Breadth-First

This is the first strong stance of SlopBurn on agentic orchestration: depth, not breadth, is the bottleneck of production-quality agentic coding.

Too much AI tooling today encourages a breadth-first mode of work: many branches, many suggestions, many parallel directions, lots of surface area. That has value, but it also makes it easy to mistake expansion for progress.

SlopBurn takes the opposite stance. It is built around depth-first descent.

Pick the chamber. Study the threat. Stay with the problem. Earn real proof before moving on.

That is not just a stylistic preference. It is a theory of software quality.

Most serious quality problems do not get solved by sampling more possibilities. They get solved by staying with the issue long enough to understand its real shape. Reliability problems, test gaps, flaky behaviors, subtle regressions, and missing invariants all reward depth. They do not reward wandering.

The roguelike metaphor makes that natural. You do not win by looking at every corridor at once. You win by surviving the room you chose to enter.

Real Specialization Through Spec And Prompting

The second strong stance in SlopBurn is that agent specialization should be real.

Most tools talk about specialization loosely. In practice, that often means a prompt with a slightly different tone: be more strategic, be more senior, be more performance-oriented. The label changes, but the underlying behavior barely does.

SlopBurn tries to make specialization structural.

Just as an RPG character levels up in Strength, Constitution, Agility, and Wisdom, a SlopBurn character becomes specialized in dimensions that match the technical debt they are trying to address. The Cutline MCP Server provides calibrated support through custom prompts to your coding agent, specialized by the attributes of your character.

Strength

Strength represents forceful implementation: big changes, bottleneck-breaking, and the kind of code surgery that actually clears a room.

Agility

Agility represents precision: surgical edits, careful rerouting, and handling fragile flows without waking three more monsters.

Constitution

Constitution represents endurance: surviving ugly systems, absorbing setbacks, and staying alive through repeated verification cycles. It naturally fits reliability work.

Wisdom

Wisdom represents judgment: threat assessment, pattern recognition, and knowing what kind of move the room is really asking for.

What matters is that progression is not just "more output." Leveling up means choosing what kind of engineer, dungeon diver, and agent commander you are becoming.

That is the point of the stat system in SlopBurn: to use RPG character progression to give a metaphorical vocabulary to software quality and skill specialization.

Again, the roguelike metaphor helps. In a real roguelike, a heavy fighter, a cautious caster, and a glass-cannon build should not approach the same room in the same way. SlopBurn applies that idea to agentic software work.

What SlopBurn Actually Does

At a practical level, SlopBurn turns your software project into a dungeon run.

It scans the terrain, spawns threats from real software-quality issues, organizes those threats into chambers and monsters, and gives you a run-state that evolves over time. You, as a SlopBurn character, inspect rooms, reveal weakpoints, plan attacks, and roll verification. Passing tests can deal damage.

As you keep going, your character advances. Your build sharpens. Your loadout matters more. The system becomes better at helping you in the style your run has earned.

Progression is not just "more AI." It is more situated orchestration.

That makes the workflow feel much closer to the true emotional shape of vibecoding:

• uncertainty
• commitment
• consequence
• recovery
• deeper descent

That is why the text-first form matters so much. SlopBurn works because vibecoding itself already happens through textual intent. The dungeon is made of descriptions, prompts, tests, logs, and choices. It does not need a visual layer to become game-like.

It already is.

The Bigger Bet

The bigger bet behind SlopBurn is that the untapped metaphor of an RPG unlocks new possibilities in agentic software engineering.

In roguelike vibecoding, the right interface should acknowledge stakes, progression, specialization, and consequence. It should help you understand not just what code could be written, but what room you are in, what threat is active, and what kind of move is justified now.

SlopBurn is the world's first vibecoding QA roguelike RPG.