← Back to Blog

Vibe Coding and Agentic Engineering Are Getting Closer Than I'd Like

• agentic-engineering, vibe-coding, ai-ethics, product-development, ai-safety, software-quality, autonomous-systems, responsible-ai

I've been building AI products for three years now, and I'm watching something uncomfortable unfold. Two trends that should have remained distinct are merging into something that makes me profoundly uneasy as both a builder and someone who thinks deeply about where this technology is headed.

Vibe coding—that feeling-driven, prompt-and-pray approach to generating code—was supposed to be a prototyping tool. Agentic engineering—autonomous systems that make decisions and take actions—was meant to be carefully architected with robust guardrails. Now they're converging, and the implications for product builders are more complex than the breathless LinkedIn posts suggest.

Understanding the Convergence

Let me be precise about what we're discussing here. Vibe coding emerged as developers discovered they could describe what they wanted in natural language and get working code back. It's intuitive, fast, and requires minimal technical overhead. You describe the vibe of what you want, and the model generates something that matches that energy.

Agentic engineering, on the other hand, represents a more sophisticated paradigm. We're talking about systems that can plan, execute multi-step tasks, make decisions based on context, and operate with increasing autonomy. These aren't simple code generators—they're systems that can navigate complex workflows, interact with APIs, and modify their own behavior based on outcomes.

The convergence happens when vibe-coded agents start making consequential decisions. When the thing you casually prompted into existence can now autonomously interact with your production database, call external APIs with your credentials, or make decisions that affect real users.

And that convergence is accelerating faster than our frameworks for managing it.

Why This Matters for Product Builders

I run a product studio where we ship AI-native products. The velocity gains from this convergence are real and substantial. I've watched our team go from concept to working prototype in hours instead of weeks. The temptation to lean into this fully is enormous.

But here's what I've learned: velocity without visibility is just chaos with momentum.

Consider what happens in a typical vibe-coding-meets-agentic-engineering workflow:

  1. You prompt an AI to build an agent that monitors customer support tickets
  2. The AI generates code that seems reasonable, includes error handling, and even has some logging
  3. You deploy it because it works in testing
  4. The agent starts making decisions—prioritizing tickets, escalating issues, maybe even drafting responses
  5. Something goes wrong, but you can't easily trace why because you didn't write the code, you prompted it

This isn't a hypothetical. I've seen variations of this pattern across dozens of products. The gap between "it works" and "I understand why it works" has never been wider.

The Control Problem Isn't Theoretical Anymore

For years, AI safety researchers talked about the control problem in abstract terms—how do we ensure AI systems do what we want? It felt academic, distant, something to worry about when we had AGI.

That was naive.

The control problem is here, just distributed across thousands of products being built by teams using vibe coding to create agentic systems. Each instance might be small, but the aggregate risk is significant.

I'm not talking about paperclip maximizers or existential risk. I'm talking about the mundane but consequential failures that happen when you have:

These aren't edge cases. They're becoming the default operating mode for a growing number of AI products.

The Quality Paradox

Here's something that keeps me up at night: the quality of vibe-coded agentic systems can be deceptively high—right up until it isn't.

Modern language models are remarkably good at generating code that works for common use cases. They include error handling, follow best practices, and often produce cleaner code than rushed human developers. This creates a false sense of security.

The problems emerge in the long tail:

When you write code yourself, you build intuition about where problems might lurk. You know which parts are brittle, which dependencies are questionable, which edge cases you're handling poorly. With vibe-coded agents, you lose that intuition.

I've started calling this the "quality paradox": the better AI gets at generating working code, the harder it becomes to identify when that code is subtly wrong.

Ethical Considerations for Builders

As product builders, we have responsibilities that extend beyond shipping fast. The convergence of vibe coding and agentic engineering raises ethical questions we need to address now, not after something goes wrong.

Accountability and Attribution

When an agentic system makes a decision that harms a user, who's responsible? The product builder who prompted it into existence? The model that generated the code? The agent that executed the decision?

Legally and ethically, the answer is clear: the builder is responsible. But the practical reality is more complex. How do you take responsibility for behavior you didn't explicitly program and may not fully understand?

This requires new practices:

Transparency with Users

Users deserve to know when they're interacting with agentic systems, especially ones that were vibe-coded into existence. This isn't just about disclosure—it's about setting appropriate expectations.

I've seen products that hide the AI nature of their agents, presumably because they worry it will reduce trust. This is shortsighted. When (not if) something goes wrong, the breach of trust will be far worse than any initial skepticism.

The Deployment Dilemma

Every product builder faces this question: at what point is a vibe-coded agentic system ready for production?

Traditional software has established practices—code review, testing, staging environments, gradual rollouts. These practices assume you understand the code you're deploying. With vibe-coded agents, you're deploying behavior, not just code.

This requires a different framework:

What I'm Doing About It

I'm not arguing against using these technologies—I'm using them every day. But I am arguing for more intentionality about how we use them.

In my own work, I've adopted several practices:

Prompt Archaeology

I maintain detailed records of the prompts used to generate agentic code. This creates a form of "source control" for vibe-coded systems. When something goes wrong, I can trace back to the original prompt and understand the intended behavior.

Layered Autonomy

I design agentic systems with explicit autonomy layers. Some decisions can be fully autonomous. Others require human approval. The most consequential require multiple approvals. This isn't just about risk management—it's about maintaining meaningful human agency in the system.

Behavioral Contracts

Before deploying any vibe-coded agent, I write a behavioral contract—a document that specifies what the agent should and shouldn't do, how it should handle edge cases, and what its success criteria are. This serves as both a design document and a testing framework.

Regular Audits

I schedule regular audits of agentic systems, reviewing their decisions, examining logs, and looking for drift from intended behavior. This is time-consuming, but it's the only way to maintain confidence in systems you didn't explicitly program.

The Path Forward

The convergence of vibe coding and agentic engineering isn't going to reverse. The capabilities are too useful, the velocity gains too significant. But we can shape how this convergence unfolds.

What we need:

Better tooling for understanding vibe-coded systems. We need IDEs and debugging tools designed for prompt-generated code. We need ways to visualize agent decision-making. We need frameworks for testing behavioral correctness, not just functional correctness.

Industry standards for agentic systems. We need shared practices around logging, explainability, and human oversight. We need to move beyond "move fast and break things" to "move fast and understand things."

Education for builders. Most developers weren't trained to build systems they don't fully understand. We need new mental models, new practices, new ways of thinking about software quality and reliability.

Honest conversations about limitations. The AI community has a tendency toward either breathless hype or existential doom. We need more nuanced discussion about what these systems can and can't do, where they're appropriate and where they're not.

The Uncomfortable Truth

Here's what makes me uncomfortable: I don't think we're going to get this right on the first try. Or the second. Or probably the tenth.

We're in a period of rapid experimentation, and experimentation means failures. Some of those failures will be minor. Some will be significant. Some might be catastrophic.

The question isn't whether we'll make mistakes—we will. The question is whether we're building the systems, practices, and culture to learn from those mistakes quickly and effectively.

As product builders, we're on the front lines of this convergence. Every decision we make about how to use vibe coding and agentic engineering sets precedents, establishes patterns, and shapes the trajectory of these technologies.

That's a responsibility I take seriously. And as these technologies get closer—closer to each other, closer to production, closer to affecting real people at scale—I hope you will too.

The future of AI products isn't just about what we can build. It's about what we should build, how we should build it, and how we maintain meaningful human agency and accountability in systems that increasingly operate beyond our direct control.

That's the conversation we need to be having. And we need to be having it now, while we still can shape the trajectory of these technologies rather than simply reacting to their consequences.

Related reading