Vibe coding vs spec-driven development: improvise, or blueprint?

Vibe coding is conversational and exploratory: you describe what you want, the agent generates code, you run it, and you steer with the next prompt based on what happened. The spec lives in your head and evolves as you go. Spec-driven development (SDD) inverts the order: you write a precise specification — the intended behavior and the tests that pin it down — first, and the agent’s job is to produce an implementation that satisfies it. The thinking is externalized before the code exists.

Spec-driven development is a repeatable loop, and each stage narrows ambiguity before the next.

Vibe coding’s failure is quiet. The agent produces code that looks right and passes the one case you tried, but the intent only ever lived in a scroll of chat — so as the project grows, context drifts, earlier decisions get silently contradicted, and "subtly wrong" accumulates faster than you can eyeball it. The very thing that makes it fast (no fixed target) is what makes it fragile (nothing to check against).

SDD pays that cost up front instead. Its risk is the mirror image: a spec that is wrong, or over-specified to the point of straitjacketing the implementation, and the ceremony is genuine overhead for a five-minute script. The skill SDD rewards is not typing speed but intent clarity and review — writing a spec that says exactly enough, and reading a diff against it. That is precisely the skill the 2026 interview loop has started testing, because it is the half of the job AI does not do for you.

You are validating an idea. Day one is pure vibe coding: you prompt a UI into existence, wire a fake backend, click around, and throw away three versions before one feels right. Writing a spec here would be waste — you are discovering the requirements by building, and the code is disposable. Speed of iteration is the whole game.

The idea lands, and now it has to become real software other people depend on. You switch to SDD: take what the prototype taught you, write it up as a spec with acceptance tests, break it into tasks, and let the agent implement each against the tests while you review. The prototype was the research; the spec is the contract. Same tools, same AI — the difference is that "done" is now defined before the code, not discovered after it. That progression, vibe to spec as stakes rise, is how the two most often coexist.