How Do We Stop Vibe Coding? — Alex Klos

BlogHow Do We Stop Vibe Coding?<br>July 24, 2026<br>On this pageIntent Above Code<br>The Problem<br>The Solutions Are Immature<br>Markdown Specs<br>Skills<br>Spec Kit & OpenSpec, etc.<br>Kiro<br>Test-Driven Development<br>Jigsaw Falling Into Place<br>CodeSpeak<br>Scryer<br>There's No Retreat

When Claude Code blew up in popularity near the end of December 2025, a large portion of software developers quickly shifted to using coding agents as part of their main development workflows.

Andrej Karpathy, who coined the term "vibe coding," stated on the No Priors podcast in March 2026:

I don't think I've typed like a line of code probably since December, basically, which is an extremely large change. I don't think a normal person actually realizes that this happened or how dramatic it was.

I believe him. A lot of people say this is just marketing or hype, but as someone who also hasn't written a single line of code since last year, I think he's being honest here. Now, whether that's good or bad depends on your perspective, but there's no doubt that we've entered a new era of software engineering.

Despite the quick adoption of agents, there's a general anxiety growing among the practitioners, and the people watching their output: will the tidal wave of slop ever end? Are we destroying ourselves for the sake of convenience here? How do we stop this?

Intent Above Code

Grady Booch, co-creator of UML, actually argues that we're in the third golden age of software engineering:

The first, from the late 1940's to the 1970's, was the age of the algorithm. High-level languages and compilers abstracted away the machine.

The second, from the 1970's to the 2000's, was the age of object-oriented abstraction.

The third, starting around 2000, is the age of systems: libraries, platforms, and APIs abstracting away entire subsystems.

Booch is careful to note that this third age wasn't started by AI, just accelerated by it. But he also compares AI coding agents to the arrival of compilers in Grace Hopper's time, and that's the comparison that matters here. Compilers abstracted away the machine. Agents abstract away the code itself.

We can now, for the first time ever, generate code directly from intent. The lack of this ability was what killed model-driven development back in the day (think what you will about UML, but maybe it's time we thought about bringing MDD back in some form.)

Practically, as we move up in abstraction towards intent we lose many of the tools and methods that made working with code a reliable process. If we can adapt, I believe that this shift could potentially not just speed up development, but also vastly improve the quality of software solutions.

Currently however, we're stuck in the vibe coding casino. Everyone and their grandma is now churning out code like there's no tomorrow, pulling the lever and hoping for the best.

The Problem

Vibe coding has almost universally been described as (a) damaging to personal understanding of solutions and architecture, and (b) unreliable because of under-specified prompts, the natural language interface being lossy, and non-deterministic code generation.

When you're vibe coding:

You stop understanding the codebases you're working in. The mental model that gets built is vague and mostly reliant on your own previous experience as a programmer.

You lose awareness of dead/redundant code and stubs.

You lose track of what was implemented and why.

You can't explain the architecture to others, or reason about potential problems.

You have almost no visibility of what will change before you approve a plan. Yes, the agent usually writes a little essay explaining what it will do, but it's limited.

It doesn't show a blast radius.

It doesn't tell you that it's only going to implement something partially, or that it omitted something crucial that you assumed was obvious.

Even if it does, you might not catch it because the plans have no learnable structure.

This is the black-box effect that slowly consumes your workflow and makes you less rigorous as a software engineer, until eventually you're blindly pushing commits and taking down production.

Even if you don't abuse coding agents this way and prefer to keep programming manually, it's hard to deny that this is probably the future of software engineering at large. We can see how many engineers are using coding agents as part of their core workflows, and how many 100x devs are already trying to create autonomous loops with them as if control and decision-making are merely distractions from the real goal: tokenmaxxing.

In any case, it boils down to trust; you can't trust your own understanding of the codebase, and you can't trust the agent did what you wanted it to do.

The Solutions Are Immature

We all understand that this is bad - but what about potential solutions? There's a lot of discussion on this topic and yet I'd argue that nothing proposed so far is remotely compelling.

First, we need to agree on...