Vibe Coding Is Dead, Long Live Agentic Engineering
Six months ago “vibe coding” meant typing a vague prompt and hoping the output compiled. I did it. It worked until it didn’t — the moment a codebase got past toy-project size, prompt-and-hope fell apart. What replaced it, quietly, wasn’t a better prompt. It was a different job description.
The shift nobody announced
I still write code every day. I just don’t type most of it anymore. The work moved up a level: instead of implementing a function, I write a spec for what the function needs to do, constraints it has to respect, and then I watch an agent build it. That’s not vibe coding — that’s what people are now calling agentic engineering, and the distinction matters more than it sounds.
Vibe coding gives AI a prompt and ships whatever comes back. Agentic engineering gives AI a specification, project context, and a human gatekeeper who reviews every diff before it lands. Same tools, completely different discipline.
The loop that actually works: Plan, Execute, Verify
The pattern I’ve landed on — and apparently most serious teams have too — is what’s being called the PEV loop:
- Plan — agent proposes an approach before touching any file. I read it like a mini design doc, not a black box.
- Execute — agent makes the changes, runs commands, iterates on its own errors.
- Verify — tests, diff review, sometimes a second agent acting as reviewer or security scanner.
The old workflow was: prompt, get code, paste it in, hope. The new one has a checkpoint before anything ships. That one change is why agentic output is trustworthy in a way vibe-coded output never was.
What my day actually looks like now
- Morning: write specs for 2-3 features, not code. Precise constraints, not vague vibes.
- Kick off an agent per spec, let them run in isolated worktrees so they don’t collide.
- Review diffs like PRs from a very fast, very literal junior engineer.
- Write the tests I actually trust — the agent writes its own, but I don’t skip mine.
- Step away while long-running tasks execute. Come back to a diff, not a blank cursor.
Some days that’s one agent. Some days it’s three or four running in parallel on unrelated pieces of the same codebase. The economics change completely once you’re supervising instead of typing — it’s less “AI helped me code faster” and more “I stopped being the bottleneck.”
Where the human still matters
None of this removes the need for judgment. Someone still has to decide what “correct” means, catch the plausible-but-wrong plan before execution, and own the architecture. The tools got better at typing. They didn’t get better at deciding what’s worth building. That part’s still mine — and honestly, that’s the part I always liked more anyway.
If you’re still stuck in prompt-and-hope mode: try writing the spec first, next time, before you touch the prompt box. The output quality difference is not subtle.
