Everyone's vibe coding now. Your LinkedIn feed says so. The Twitter/X threads say so. The "I built a SaaS in a weekend with zero code" posts definitely say so. But here's what nobody's telling you: most of what gets called "vibe coding" is actually two very different things happening under the same name — and one of them ships production software, while the other creates a graveyard of unmaintainable projects and false confidence. The difference has a name. And it matters more than most people realize. ![Vibe Coding vs. Agentic Engineering: The Difference Is Whether You're Still Driving](/assets/images/infog/vibe-coding-vs-agentic-engineering.webp) ## What Agentic Engineering Actually Means Agentic engineering is what happens when you use coding agents — tools like Claude Code, OpenAI Codex, Gemini CLI — with intentionality. These agents write and *execute* code in a loop. They can iterate toward working software. That execution capability is what makes the whole thing different from autocomplete. But here's what Simon nails that most people miss: **agents didn't make the engineering judgment disappear. They just made the typing cheaper.** Code has historically been expensive to produce. A few hundred lines of clean, tested, production-ready code could easily take a skilled developer a full day. That constraint shaped *everything* — how we plan, how we estimate, what features get built, what gets skipped. Our entire professional intuition about software was calibrated to that cost. Coding agents dropped the cost of *typing code* to near zero. They did not drop the cost of *good code.* Good code still means: it works, and you *know* it works. It handles errors gracefully. It's tested. It's documented. It won't make future changes into a nightmare. All of that still requires a human who's paying attention, making decisions, reviewing output, and maintaining standards. **Agentic engineering is still engineering. The agent is the vehicle. You're still the driver.** ## The Diagnostic: Which Mode Are You Actually In? Here's a quick way to figure out where you actually are when you're building with AI: **You're vibe coding if:** - You can't explain why the code does what it does - You're accepting outputs without reading them - "It works" is your only test - You couldn't maintain or debug it without regenerating from scratch - Your context is a chat window, not a document **You're doing agentic engineering if:** - You have a PRD, a spec, or at minimum a clear mental model before prompting - You review what gets generated and make decisions about it - You're running actual tests, not just "does it load" - You're tracking what the agent knows through structured context (CLAUDE.md, continuity docs, memory files) - You could explain the architecture to another developer **The dangerous middle — and this is where most people actually are:** - You're generating code fast and feel productive - You're not quite reading it carefully - You're not testing edge cases - You've outsourced your engineering judgment without realizing it **If you recognized yourself in that list, here's your one move:** Before your next prompt session, write a one-page PRD. Not a spec document, not a technical design — just one page answering: what problem does this solve, who uses it, what does done actually look like, and what are the three things that must not break. That document becomes your context anchor. It's what you hand the agent at the start of every session. It's what you check your outputs against. It's the difference between driving and drifting. Everything else follows from having that page. This is where technical debt accelerates at AI speed. You're getting the output volume of agentic engineering with the quality assurance of vibe coding. That combination will find you eventually. There's a specific failure mode I call **Token Debt** — and it's worse than regular technical debt because it's self-reinforcing. It goes like this: the agent generates bad architectural code early on. You don't catch it because you're in passenger mode. Later, something breaks. So you paste the broken code *back into the agent* and ask it to fix it. The agent patches it. Something else breaks because the patch didn't understand the original problem. You paste that in too. Now you're burning context window and API credits feeding an AI its own bad decisions, spiraling deeper into a codebase that nobody — human or machine — fully understands anymore. Regular technical debt costs you future developer time. Token Debt costs you that *plus* active compute spend, *plus* context degradation, *plus* the compounding confusion of an agent that's been reasoning from flawed premises across a long session. The meter is running while you dig the hole deeper. The driver catches bad architecture at the foundation. The passenger discovers it three weeks later when the fix costs more than the original build. ### The Mirage of Completeness There's a visual trick that vibe coding plays on you that agentic engineering doesn't. When you vibe-code a project, you often end up with something that looks finished. The UI is there. The buttons work. It looks like a product. But underneath, the error handling is thin or missing, the edge cases were never considered, the backend is doing exactly what the happy path needs and nothing else. Paint without plumbing. Agentic engineering is fundamentally about the plumbing — the parts nobody sees. The error states. The validation. The test coverage. The graceful degradation when something goes wrong at 2am. Tindlekit's deployment guide has a whole troubleshooting section not because things always break, but because someone *thought about* what breaks and built recovery paths for it. That's not vibe energy. That's engineering. The mirage is dangerous because it passes demos. It fools investors. It even fools the builder. Right up until a real user finds the edge case you never handled. ## The Meta-Point: This Is a Thinking Mode If you've read my book *Thinking Modes: How to Think With AI*, you'll recognize the pattern here. Vibe coding is a valid thinking mode — generative, exploratory, low-friction. It's excellent for divergent phases, for prototyping, for "let's see what's even possible." Agentic engineering is a different mode: convergent, intentional, accountable. You're directing execution toward a defined standard. But there's a layer underneath both of those that most people never get to: **metacognition**. In agentic engineering, you're not just thinking about the code. You're thinking about *how to tell the agent to think about the code.* You're writing prompts that encode your architectural values. You're structuring context documents so the agent doesn't drift from your intent. You're reasoning about the agent's reasoning. That's a different cognitive level entirely — and it's exactly what separates engineers who get compounding results from AI tools from those who plateau. This is the skill that *Thinking Modes* is really about. Not which tool to use, but which cognitive mode you're operating in — and whether you're doing it consciously. The mistake isn't using vibe coding. The mistake is staying in vibe mode when you've crossed into a phase that requires engineering mode — and not noticing the transition happened. The best builders I know move fluidly between both. They vibe to explore, then shift modes to build what survives contact with reality. The question isn't *which mode is better.* The question is: **do you know which mode you're in right now?** ## Frequently Asked Questions ### What Vibe coding — in its original definition from Andrej Karpathy — means prompting an AI to write code while you forget the code even exists. You describe what you want, the AI produces it, you don ### Is vibe coding bad? No. It ### What is Token Debt? Token Debt is a failure mode specific to AI-assisted development, and it ### Do I need to know how to code to do agentic engineering? You need enough technical literacy to review what the agent produces and recognize when something is wrong — not necessarily to write the code yourself. The judgment layer is what agentic engineering requires, not the typing layer.\n\nThat said, the less technical context you have, the more important your other structures become: a clear PRD, explicit success criteria, a defined test for \ ### What is a PRD and why does it matter for AI coding? PRD stands for Product Requirements Document. At its simplest it ### What tools do agentic engineers actually use? The core tools right now are coding agents that can both write and execute code in a loop: Claude Code, OpenAI Codex, and Gemini CLI are the main ones. The execution capability is what makes them different from a regular chatbot — they can iterate toward working software, not just output text.\n\nBeyond the agents themselves, agentic engineering relies on structured context: CLAUDE.md or equivalent files that tell the agent about your project, continuity documents that carry state across sessions, and PRDs that anchor intent. The tools change fast; the discipline of structured context doesn ### How do I know if I Ask yourself three questions right now:\n\n**One:** Before your last prompt session, did you write down what \ ### Can vibe coding and agentic engineering coexist in the same project? Yes — and the best builders move fluidly between both. They vibe to explore, then shift modes to build what survives contact with reality.\n\nA common pattern: vibe code a rough prototype to validate that the idea works at all, then stop, write a proper PRD based on what you learned, and rebuild the foundation with agentic engineering discipline. The prototype was never meant to survive — it was research. The rebuild is the product.\n\nThe mistake isn --- *Carmelyne Thompson is a Filipino solopreneur, systems thinker, and builder with 25+ years in full-spectrum web development. She's the author of* Thinking Modes: How to Think With AI *(available at carmelyne.com/Gumroad) and the creator of Terrakindle, an ecological global stewardship framework. She writes about human-AI collaboration for builders who are still driving.*