The Siren Song of Vibe Coding

Let's be honest: we've all been there. It's late at night, you're staring at a blank IDE, and someone suggests, "Just use AI for that." So you paste in a prompt, watch the tokens flow, and boom — code appears. It looks right. It feels right. You're vibe coding.

The problem? That warm fuzzy feeling is lying to you.

Wes McKinney, the creator of pandas and co-creator of Apache Arrow, recently shared his thoughts on this phenomenon, and it should be a wake-up call for anyone who's replaced proper engineering discipline with clever prompting. Vibe coding — the approach where you let AI generate code with minimal oversight based on vague intentions — is dangerous not because AI is bad, but because it removes the human from the critical thinking loop at exactly the wrong moment.

What Vibe Coding Actually Looks Like

Here's the typical vibe coding workflow: You need a feature. You open ChatGPT or Claude, describe what you want in broad strokes, get back a wall of code, paste it into your project, and move on. Maybe you skim the output. Maybe you even run the tests — if there are tests. If the code "works" (i.e., doesn't immediately crash), you're done.

Sound familiar? Yeah, we thought so.

The danger isn't that the AI produces bad code (though it certainly can). The danger is that you've outsourced your architectural thinking, your edge case analysis, and your understanding of the system to a black box that has no idea what your production environment looks like.

Agentic Engineering: The Discipline That Actually Scales

McKinney's alternative isn't anti-AI — it's pro-disciplined-AI. Agentic engineering is a structured approach where AI coding agents operate within guardrails, following defined specifications and undergoing continuous review.

Think of it as giving your AI assistant a job description rather than just vague instructions.

The Spec-Driven Workflow

The cornerstone of agentic engineering is spec-driven development. Before any code is written (by human or machine), you define what the system should do in precise, testable terms. This specification becomes the contract that guides all subsequent work.

When an AI agent operates from a clear spec, it can:

• Generate code that actually meets requirements
• Self-verify against defined acceptance criteria
• Flag ambiguities before they become bugs
• Maintain consistency across a growing codebase

This isn't slower — it's faster in the long run because you're not constantly retrofitting AI-generated code that doesn't quite fit.

Continuous Code Review, Automated

McKinney mentioned working with tools like Roborev for continuous AI code review. This is where agentic engineering really shines. Instead of treating AI as a code generator, you use it as a tireless reviewer that catches issues before they reach human review cycles.

Automated code review with AI means:

• Style inconsistencies get flagged immediately
• Security vulnerabilities are spotted early
• Performance anti-patterns don't slip into production
• Knowledge transfer becomes systematic, not accidental

The Token Economics Reality

Here's something vibe coders don't think about: every prompt has a cost. Not just in dollars (though that adds up fast), but in cognitive overhead and maintenance burden.

When you vibe code, you're generating tokens that produce code you don't fully understand. That code needs to be maintained, debugged, and extended by humans — usually the same humans who wrote it with AI. If you don't understand the code, every future modification becomes a risk.

Agentic engineering, done right, produces code that's understandable because the human was involved in the spec and the review. The token investment happens upstream (in defining the spec clearly) rather than downstream (in untangling mysterious code).

The Real Danger of Vibe Coding for Startups

For early-stage startups and fast-moving dev teams, vibe coding feels like a competitive advantage. Ship faster, iterate quicker, let AI handle the boilerplate.

But here's the trap: technical debt compounds. Code you don't understand is technical debt by definition. And unlike other forms of debt, this kind grows interest faster than you can pay it down.

We've seen startups reach a point where they can't ship features anymore because their codebase is a Frankenstein monster of AI-generated snippets that no one fully owns. The "velocity" they gained early on becomes a massive slowdown as they try to untangle their way out.

A Better Way Forward

So what's the alternative to vibe coding? It's not going back to manual everything. It's being intentional about when and how you use AI.

1. Spec first, always. Define what you want before you ask AI to build it. Treat AI as a implementation tool, not a thinking tool.

2. Review as you go. Don't just paste AI code — review it, understand it, and verify it against your spec. Use AI-assisted review tools to scale this process.

3. Understand your token economics. Every AI interaction has a cost. Invest those tokens in quality rather than quantity.

4. Maintain the human in the loop. AI should augment your engineering judgment, not replace it. The moment you stop thinking critically about your code, you've started vibe coding.

5. Document for the future. If an AI wrote it, you still own it. Make sure your codebase remains understandable to the humans who'll maintain it.

The Bottom Line

AI coding assistants are genuinely transformative tools. But like any powerful tool, they require discipline to use safely. Vibe coding throws that discipline out the window in exchange for short-term feel-good productivity.

Agentic engineering — structured, spec-driven, continuously reviewed — is how you get the benefits of AI without the hidden costs. Wes McKinney's approach isn't the only way to use AI coding agents effectively, but it is a reminder that the best engineers aren't the ones who use AI the most. They're the ones who use it the most intentionally.

The future of development isn't vibe coding. It's engineering done with intention, with AI as a powerful assistant rather than a crutch. And that, ultimately, is how you build software that actually lasts.