Vibe Coding Was Just the Prologue. The Day Developers Become Conductors Through 'Agentic Engineering'

Vibe Coding Was Fun. But I’m Starting to See Its Limits

Open Cursor and give instructions in natural language. AI writes the code. That moment when it works—no matter how many times I experience it, the thrill is unmatched.

I encountered vibe coding about a year ago. Originally I worked at a web development company doing both front and back end. I was overwhelmed by the level of engineers I met on a large-scale project, so I stepped away from code. After several years in customer success, I encountered Cursor and Claude Code. It felt like an elite engineer had taken up residence inside me.

That joy of revival was the real deal.

But as I continued with vibe coding, I started noticing things. Issuing instructions in chat, checking the returned code, requesting fixes, checking again. There’s no doubt this loop is fun. But when asked whether it’s efficient, increasingly the answer gets murky.

Once files exceed about ten, vague instructions return code that misses the intent. Say “fix this part” and something else breaks. In the end, I felt I had become the bottleneck.

I bet a lot of people feel the same way.

Search “vibe coding tired” on X and you’ll find plenty of similar voices. “Giving AI instructions is more exhausting than just implementing it.” “I end up having to check everything myself anyway.” “It falls apart as files multiply.” After the frenzy phase of vibe coding, my impression is that more people are entering a phase of confronting reality.

Actually, an answer to this “wall” is already taking shape as an established concept in the English-speaking world. Its name is “Agentic Engineering.” Japanese explanations are still virtually nonexistent. Today, I’ll translate this concept from the perspective of someone who has been through vibe coding.

What Is “Agentic Engineering”?

Agentic Engineering. A literal translation would be “agent-like engineering,” but that doesn’t really tell you what it means.

To break it down a bit more, it’s this.

Vibe coding: A style where a human chats with AI and writes code one piece at a time

Agentic engineering: A style where the human conveys intent and design, while AI agents (autonomously operating AI programs) handle the loop of generation, testing, and revision. The human focuses on directing, reviewing, and recovering

In other words, the developer’s role shifts from “person who writes code” to “person who directs AI agents.”

This concept spread rapidly in English-speaking tech communities entering 2026. The explanation at dasroot.net is a good reference. The definition: convey intent in natural language, let agents handle the generation and revision loop, while humans focus on instruction, review, and recovery.

I’ve decided to call this the “conductor model.”

An orchestra conductor doesn’t play the violin themselves. But they understand the design of the entire piece, give precise instructions to each part, and can judge the quality of the performance. The developer’s role in agentic engineering has exactly the same structure.

Vibe coding feels like “learning to play one instrument at a time while being taught.” Agentic engineering feels like “stepping onto the podium and moving the whole orchestra.” Even if you can’t play an instrument, a good performance is born.

So what exactly does an agent do autonomously? Roughly organized, it looks like this.

• Code generation: Writing implementation code from requirements. This is the same as vibe coding
• Test creation and execution: Auto-generating test code, running it, and checking results
• Self-correction of errors: When tests fail, analyzing the cause and attempting fixes
• File operations: Creating new files, editing existing ones, organizing directory structures
• Git operations: Automating commits, branch creation, and even diff checks

The decisive difference from vibe coding is “running the loop yourself.” There’s no need for the human to check every time and issue the next instruction. The agent judges for itself and moves to the next step.

This is seriously shocking when you experience it. At first you get anxious—“Is it really okay to leave this to it?” But when you see the deliverable, you’re surprised. Quite often, the quality is higher than what you’d produce running it manually.

Claude Code’s 46% Shows Where Agent Development Stands Today

“I get the concept. But is it usable now?”

It is. In fact, the number of people already using it is surging.

Pragmatic Engineer conducted a survey of over 900 developers. Claude Code took first place at 46% for “most loved development tool.” Cursor came in second at 19%, and GitHub Copilot third at 9%.

Why is Claude Code so widely supported? The reason is simple: Claude Code is exactly a practical tool for agentic engineering.

Claude Code is an agent that runs on the CLI (command-line interface). Rather than a GUI chat, you issue instructions directly from the terminal. It can autonomously handle file reading and writing, test execution, and even git operations.

For example, you instruct: “Add validation to this API and write tests too.” Then beyond just modifying code, it proceeds to creating test files and running them. If errors come up, it cycles through to automatic fixes all at once.

# Example instruction in Claude Code
# Just convey design intent in natural language

> Build a Slack notification filtering bot.
> Requirements:
> - Classify notifications from specific channels by importance
> - Send daily summaries via DM
> - Make filtering rules configurable via YAML
> - Write tests too

# → Claude Code autonomously progresses from file structure → code generation → tests → execution

Vibe coding is like “shogi played one turn at a time.” Agentic engineering feels like “a shogi AI that, once you convey the strategy, plays multiple moves at once.”

As the AI coding tool market grows overall, competition is intensifying. Reports indicate Cursor is in talks for fundraising at a $50B (about ¥7.5 trillion) valuation. That’s 71% up from the previous $29.3B. A number that shows you the market’s expectations.

Intensifying competition among tools is itself a good thing. More choices, sharper features, lower prices. What matters isn’t betting on a specific tool. It’s getting accustomed to the working style of “directing agents.” Tools may change, but the conductor’s role doesn’t.

Why 65% of Developers Feel “The Role Is Changing”

Industry surveys aimed at developers all point in the same direction. A shift is accelerating from routine coding to architecture design, system integration, and AI decision support. This trend shows up in the numbers in the Pragmatic Engineer survey too.

This really clicked for me.

The strength of the elite engineers I once met on large-scale projects was their architectural design ability. Not the speed of writing code, but how to assemble an entire system. A domain I couldn’t reach back then.

But in the context of agentic engineering, the meaning of “design ability” changes.

Getting an AI agent to write code requires verbalizing what you want to build. Requirements definition, data flow, error handling policy. Those who can convey these accurately are the ones who can produce good code in this era.

Here’s what I realized: this overlaps significantly with the muscles I trained in customer success.

Listening to user requests and conveying them to the development team. Prioritizing and explaining business impact. What I’d been doing as a CS veteran had almost the same structure as giving instructions to agents.

A career detour I had thought was a setback turns out to be the shortest route in the era of agentic engineering. I can’t stop finding this reversal fascinating.

The “AI composer” professional concept proposed by IBM points in the same direction. Not just coders, but also marketers and PMs take on the role of designing and operating AI agents. It’s an era where what’s asked is not “can you write code?” but “do you know what to build?”

This isn’t just about engineers. Whether you came from sales or design, anyone who can accurately verbalize a problem has potential to produce results. The democratization of development goes one level deeper than vibe coding. That kind of future is coming into view.

How the “Conductor Model” Actually Changes Development

The theory makes sense. So what actually changes?

Let me share my experience recently building a work tool with Claude Code. It was a project to build a bot for organizing internal Slack notifications.

The vibe coding era approach:

1. Tell Cursor “build a Slack bot template”
2. Check the returned code
3. Tell it “add notification filtering”
4. A loop of checking, requesting fixes, checking, requesting fixes
5. Run tests manually
6. Find errors and request more fixes

This repetition took a full day before something working was ready.

The agentic engineering approach:

1. Convey design intent to Claude Code. “A bot that classifies notifications from specific Slack channels by importance and sends daily summaries via DM. Make filtering rules configurable via YAML”
2. Claude Code autonomously progresses from proposing file structure, to code generation, to test creation, to execution
3. If errors come up mid-way, it tries to fix them itself
4. I focus on review and policy decisions

The result: a working prototype completed in about 3 hours. With test code attached, no less.

A full day became 3 hours. But I don’t think it’s a story of “8x faster” or anything like that. What changed fundamentally was “how I use my brain.”

In the vibe coding era, I kept consuming my brain’s working memory through the instruct-check-fix loop. That’s exhausting. By evening, judgment slipped and I’d miss silly bugs.

In agentic engineering, once you’ve conveyed design intent, “waiting time” emerges. During that time you can organize documentation or think about the next requirement. The allocation of brain resources changes.

Let me flag a pitfall upfront. If your initial “way of conveying design intent” is sloppy, it won’t work. Just saying “build a Slack bot” gives you the same result as vibe coding.

Organize requirements as bullet points and verbalize the data flow. Communicate edge cases too. This “ability to verbalize design” is the core.

Conversely, as long as you can verbalize design, implementation skill isn’t tested. It’s a different muscle from the “ability to perfect code beauty” that professional engineers have. This was a happy point for me as someone from a CS background.

Let me add another pitfall. There will be moments when you don’t understand the meaning of the code the agent produced. The state of “it works, but I don’t know why it works.” Honestly, this is an anxious moment.

My coping method is simple. I ask the agent back, “explain this process line by line in Japanese.” If reading the explanation makes me satisfied, OK. If I’m not satisfied, I change direction with “rewrite this more simply.”

Even without perfect understanding, you’re fine as long as you can make policy decisions. In exchange for not needing to write everything yourself, you need to sharpen the “ability to judge correctness.” It’s the wall to climb one level up from vibe coding.

Another important thing is knowing “when to stop the agent.” Agents that keep running autonomously can also charge ahead in the wrong direction. Decide review points in advance. Setting checkpoints like “once you reach this point, show me” dramatically lowers correction costs.

Wrap-Up. The Landscape Beyond Vibe Coding

Vibe coding was a prologue. The experience of writing code while chatting with AI was the best entry point to democratized development. Without that excitement, the me of today wouldn’t exist.

But a prologue is a prologue. The style of issuing instructions one line at a time in chat has limits. It falls apart when files multiply, and you wear yourself out in the verification loop. Beyond that came into view a new development style called agentic engineering.

Let me organize what I’ve covered.

• Vibe coding: A human writes code one piece at a time through dialogue with AI
• Agentic engineering: A human conveys design intent, and AI agents autonomously run the loop of generation, testing, and revision
• Developer’s role: From person who writes code to person who directs AI agents
• Required skills: More than coding ability—the ability to verbalize design and judge business context
• What you can do right now: Start with the experiment of “handing over design intent as bullet points” using Claude Code

As the fact that Claude Code drew 46% support shows, agent-style tools are no longer “a story of the future.” With the redefinition of developer roles progressing industry-wide, if you’re going to start moving, sooner is better.

I believe those who think “I don’t have the skill of a professional engineer” can benefit the most. Because differences in coding skill no longer directly determine development outcomes.

I, who once stepped away from code, came back through vibe coding. And now I’m finding a new position called the “conductor model” through agentic engineering. There’s a feeling that the setbacks and detours all connect.

For those thinking “so what should I start now?” Open Claude Code and start with the experiment of handing over design intent as bullet points. Instead of instructing one line at a time in chat, summarize your requirements in five lines and hand them over all at once. That alone gets you at the entrance.

For those who haven’t touched code yet, and for those who have stopped at vibe coding—the door to the next stage is already open.

I want to tell my former self: “Stepping away from code wasn’t a detour.” The time spent listening to user voices is now transforming into instructions to agents. That is the essence of the “conductor model.”

Want to start preparing to become a conductor?