Agentic Engineering: Why Vibe Coding Is Just the Start

Vibe coding is a slur (according to its most famous practitioner)

In early 2026, Peter Steinberger — creator of OpenClaw, the open-source AI agent that reached 180,000 GitHub stars in a matter of days — sat down with Lex Fridman for a wide-ranging conversation about the future of software development. One comment landed differently than the rest:

“I actually think vibe coding is a slur. I always tell people I do agentic engineering, and then maybe after 3 AM I switch to vibe coding — and then I have regrets the next day.”

It was said with a laugh, but the point was serious. There's a meaningful distinction between the two terms — and understanding it is the key to being competitive in the next phase of software development.

What vibe coding actually is (and why it's only the start)

The term “vibe coding” was coined by Andrej Karpathy in early 2025 to describe a workflow where developers describe intent in natural language and let AI tools generate the implementation. It was playful, accessible, and genuinely transformative for many developers.

But vibe coding, in its purest form, is reactive. You describe → the AI generates → you review and ship. It's faster than writing everything by hand, but it's still a relatively linear, human-paced process.

Agentic engineering is something different. It's the discipline of working with autonomous AI agents — systems that can plan, execute multi-step tasks, read codebases, run tests, iterate on failures, and produce working software with minimal human intervention. It's not just prompting; it's orchestration, architecture, and collaboration with entities that have their own context, limitations, and working style.

The agentic trap: a curve everyone goes through

Steinberger described what he calls “the agentic trap” — a pattern he's seen repeated by almost everyone who seriously engages with AI-assisted development. It goes through three distinct phases:

1. The beginner phase: short, simple prompts. You start with “Please fix this” or “Add a login page.” It works better than expected. You're hooked.
2. The trap: maximum complexity. You build elaborate multi-agent orchestration systems. Eight agents chained together. A library of 18 custom slash commands. Complex sub-agent workflows. You're organized, you feel like a sophisticated power user. You are spending enormous energy managing the system instead of building things.
3. The elite level: back to zen simplicity. Over time, you learn what actually works. Short, precise prompts. Clear context. Good system documentation. You're not managing the agent anymore — you're directing it. The complexity lives in the agent's capabilities, not in your orchestration.

Most people who struggle with AI tools are stuck in phase two — building elaborate scaffolding to manage complexity that wouldn't be necessary if they understood the medium better. The goal isn't to build a bigger control system. It's to build better judgment about when and how to use the agent.

What agentic engineering actually looks like

Steinberger runs four to ten Claude Code or Codex agents simultaneously, each working on different aspects of OpenClaw. One builds a large feature. Another explores an uncertain architectural idea. Two or three fix bugs or write documentation. He uses voice for most interactions — his hands, he says, are “too precious for typing now.”

But beyond the mechanics, what's striking is the mindset. He describes working with agents like leading a team of capable engineers who always start fresh:

“You have to almost consider how Codex or Claude sees your codebase. They start a new session and know nothing about your project. Your project might have a hundred thousand lines of code. So you've got to help those agents a little bit — keep in mind the limitations of context size, guide them where they should look.”

This is empathy — understanding the agent's perspective, knowing its limitations, and structuring your collaboration accordingly. It's a skill that doesn't come from one afternoon with Cursor. It comes from months of working with agents on real problems.

The skill set that actually matters

What separates a competent vibe coder from a skilled agentic engineer? Based on the patterns that emerge from working engineers who've gone deep with AI tools, the core skills look like this:

• Context architecture — Knowing how to structure your codebase, documentation, and system context so agents can navigate it effectively. This means good naming, clear separation of concerns, and maintaining files like AGENTS.md that give agents the orientation they need.
• Prompt precision — Short, specific, well-bounded requests outperform long elaborate prompts. The skill is knowing how to decompose a complex goal into agent-sized tasks.
• Knowing when to step in — If an agent is taking too long, or if something feels off, the skilled agentic engineer stops and reassesses. Something in the architecture or the prompt is making the task harder than it should be.
• Letting go of aesthetic control — Agents will write code differently than you would. The mature approach is accepting that a working solution in an agent-readable style is better than a perfectly stylized solution you had to write yourself.
• Design judgment — What should be built at all? What belongs in core vs. a plugin? Where do you say no? These decisions can't be automated. They require taste, vision, and system thinking.

Coding designed for agents, not just for humans

One of the most forward-looking ideas Steinberger discussed is the notion of writing code that agents can navigate, not just code that humans can read:

“I'm not building the codebase to be perfect for me. I want to build a codebase that is very easy for an agent to navigate. Don't fight the name they pick, because it's most likely the name that's most obvious in the weights. Next time they search, they'll look for that name. If I decide I don't like the name, I just make it harder for them.”

This is a genuinely new kind of software design thinking. The audience for your code isn't just future human developers — it's the agents that will modify it. The ergonomics of a codebase now have to account for how a large language model will search, understand, and navigate it.

Self-modifying software is already here

Perhaps the most striking aspect of OpenClaw's development story is that the software modifies itself. Steinberger made the agent deeply aware of its own source code — it knows what it is, how it runs, where documentation lives. The result is that when you're unhappy with something, you can simply prompt it into a different form:

“People talk about self-modifying software. I just built it and didn't even plan it so much. It just happened.”

The implications for software architecture and development workflows are profound. When software can understand and modify itself through natural language instructions, the cycle of ideation-implementation-deployment compresses dramatically. The bottleneck shifts away from implementation capacity and toward design judgment and architectural clarity.

What this means for developer careers

The shift from vibe coding to agentic engineering isn't just about tools or workflows. It's about the kind of developer that thrives in the next era.

The developers who will command the highest demand aren't necessarily the ones who can write the most elegant code from memory. They're the ones who can:

• Architect systems that agents can effectively build and maintain
• Direct multiple agents toward coherent product goals simultaneously
• Make good design and product decisions faster than agents can produce alternatives
• Know when AI output needs human judgment and when it can be trusted
• Communicate with precision — the skill that makes prompts actually work

These are skills adjacent to but distinct from traditional programming. They require technical depth, but also product sense, communication ability, and the kind of judgment that comes from building real things over time. They are, in short, the skills of a builder — not just a coder.

At some point, as Steinberger put it, “it's just gonna be called coding again, and it's just gonna be the new normal.” But right now, the developers who understand the distinction between vibe coding and agentic engineering are the ones leading that transition — and getting paid accordingly.

Getting started with agentic engineering

If you want to move beyond vibe coding into genuine agentic engineering, here's where to start:

1. Build something real with an agent. Not a toy project — something with actual complexity, multiple files, real constraints. You'll learn more from one real project than from ten tutorials.
2. Resist the orchestration trap. When things get complicated, the instinct is to add more scaffolding. Usually the right answer is simpler prompts and clearer context.
3. Learn to read the agent. When it's struggling, ask yourself: did you give it enough context? Is the architecture making the task harder than it needs to be? The agent's behavior is feedback about your setup.
4. Write your AGENTS.md. Give your codebase an orientation document for AI assistants. Describe what the project is, how it's structured, and where to look for key things. It takes an hour and it pays off immediately.
5. Browse jobs at companies doing this for real. Remote agentic engineering roles are increasingly available at forward-thinking companies. These are the places where you'll grow fastest.

The age of agentic engineering isn't coming. It's already here, being built by people who learned that vibe coding was just the beginning.

Keep reading

• Vibe Coding Workflow
• Ai Coding Tools