I gave someone feedback recently that I keep thinking about.
They're a solid developer. Good instincts, strong architectural sense, can reason through complex problems. But there was a pattern - they'd jump straight into building, skip the scoping, skip the tests, and then spend hours debugging live calls when a 30-second mock test would have caught the problem on day one.
I called it vibe coding.
Not as an insult. As a diagnosis.
Vibe coding is what happens when you trust your intuition over your process. You open the editor, start writing, and figure it out as you go. It feels productive. You're in flow. Things are getting built. But you're also accumulating invisible debt - in untested assumptions, undocumented decisions, and scope that keeps quietly expanding.
AI tools have made this worse, by the way. When you can generate a working implementation in minutes, the temptation to skip the boring stuff gets harder to resist. Why write a test when the code already looks right?
Here's why: because "looks right" is not the same as "works right." And the gap between those two things is where production incidents live.
Vibe engineering is different.
It's not about being slow or cautious. It's about bringing discipline to speed. You can still move fast - you just move fast with guardrails.
The difference shows up in small things:
- Before you build, you scope. Not a 10-page spec. Just: what are we actually doing, and how will we know it works?
- You write mock tests before you write code. Not after. A mock test that runs in 30 seconds lets you test 50 scenarios in an hour. A live call that takes an hour lets you test one.
- You document architectural decisions in the repo - README, comments, wherever future-you will actually look.
- When something takes longer than estimated, you flag it early. Not when the deadline is tomorrow.
None of this is revolutionary. It's just discipline. The kind that compounds.
The vibe coder and the vibe engineer can produce the same output in the short run. The vibe coder might even ship faster at first. But the vibe engineer's code survives contact with the real world. It can be tested, extended, handed off. It doesn't collapse when someone else touches it.
AI tools remove friction from writing code. They don't remove the need for engineering judgment - for asking whether you're building the right thing, whether it'll hold up, whether the next person will understand what you did and why. That judgment doesn't come from the model. It comes from the engineer.
Vibe coding gets you to a demo. Vibe engineering gets you to production.
TL;DR
- Vibe coding: fast, intuitive, no process - great for prototypes, dangerous for production
- Vibe engineering: fast AND disciplined - mock tests, upfront scoping, documented decisions
- AI tools accelerate vibe coding. Engineering judgment is the antidote.
- The goal isn't to move slower. It's to move fast with intention.