How to Code with AI: From Vibe Coding to Agentic Engineering

The Agentic Trap: A Curve You'll Recognize

Here's what happens to everyone who starts coding with AI:

Stage 1: You start simple. "Please fix this bug." Short prompts. It works!

Stage 2: You get excited. You build elaborate systems — eight agents running in parallel, complex orchestration, multi-checkout chaining, custom workflows, a library of 18 different slash commands. You feel like a super-organized, sophisticated software engineer.

Stage 3: You reach the zen level. You realize simple prompts work better. You're back to: "Hey, look at these files and make these changes."

The Single Most Important Skill: Agent Empathy

Here's what separates elite agentic engineers from everyone else: empathy with the agent.

Yes, it sounds weird. They're not alive. But consider this:

• AI agents start every session with zero knowledge of your project
• Your codebase might have 100,000 lines of code — it doesn't all fit in context
• They can only "see" what you show them
• They don't know your business logic, your architecture decisions, or why you named things the way you did

Good agentic engineers think: "If I knew nothing about this project and was dropped in right now, what context would I need?"

Practical Empathy Tips

• Point them to relevant files: "Look at the auth module in /src/auth/ and the database schema in /db/schema.ts"
• Explain the architecture: "This is a Next.js app with Supabase backend and tRPC for API routes"
• Share the intent: "We're trying to add user roles, but we need to maintain backward compatibility with existing sessions"
• Set constraints: "Don't modify the payment flow — that's production-critical"

Why World-Class Programmers Sometimes Struggle

Here's a counterintuitive truth: incredible programmers sometimes fail at agentic engineering.

Why? Because their expertise becomes a burden.

The agent might come up with a different approach — maybe even a better one. It was trained on millions of codebases. It might know patterns you don't.

It's like leading an engineering team. Your employees won't write code exactly how you would. But if you micromanage everyone, they'll hate you and move slowly. Some level of acceptance that the code won't be perfect — but will work — is essential.

Voice-First Development

Here's something that surprises people: elite agentic engineers often talk to their agents instead of typing.

Why voice?

• It's faster for complex explanations
• It's more natural — you're having a conversation, not writing documentation
• It encourages brevity — you don't over-engineer prompts when speaking

You still type for quick commands and terminal operations. But for explaining what you want? Voice is king.

Move Forward, Never Revert

Traditional dev workflow: something breaks → git revert → start over.

Agentic workflow: something breaks → ask the agent to fix it → move forward.

This works because modern agents are incredibly good at fixing their own mistakes. You say "this broke the login flow" and they figure out why and fix it — often faster than you could debug it yourself.

Build Codebases for Agents, Not Humans

This is a mindset shift that takes time to internalize: you're not building a codebase that's perfect for you anymore. You're building one that's easy for agents to navigate.

What this means:

• Obvious naming: Use the names agents expect. Don't get clever with abbreviations.
• Clear file organization: Group related code together. Use conventional folder structures.
• AGENTS.md files: Create documentation specifically for AI agents — what the project does, key files, conventions.
• Modular architecture: Smaller, focused files are easier for agents to work with than monolithic files.

The Skills That Actually Matter

Here's what you need to learn to code with AI in 2026:

The Human Touch: What Agents Can't Do

AI handles the implementation. But you bring something agents can't:

• Style: The little jokes, the personality, the voice
• Delight: That moment when users smile because something just feels right
• Taste: Knowing which features to add and which to cut
• Vision: How all the pieces fit together into something meaningful

The job of an agentic engineer is to infuse AI output with humanity. Take what the agents build and make it feel like something a person made with care.

Learning the Language

Working with AI agents is like learning a new instrument. You can't read one article and become a virtuoso.

• You have to play — actually build things with agents
• You have to feel the friction — when prompts aren't working, figure out why
• You have to develop intuition — knowing when to guide vs. when to let them work

The good news? Unlike traditional programming, you don't need to memorize syntax. You just need to get good at having productive conversations with AI.

The Daily Workflow

Here's what coding with AI looks like in practice:

1. Start 3-8 agent sessions in parallel — maybe one builds a feature, one fixes bugs, one writes docs
2. Give each a clear task with enough context to work autonomously
3. Let them work — check in periodically, answer questions
4. Review output — catch issues, request fixes
5. Commit when satisfied — not when perfect, when good enough
6. Add human polish — the style, the delight, the finishing touches

Notice what's missing: writing code yourself. The vast majority of your time is spent directing, reviewing, and polishing — not typing code.

Key Takeaways

• Avoid the agentic trap: Simple prompts work better than complex orchestration
• Develop agent empathy: Understand how they see your codebase
• Use voice: Talk to your agents instead of typing elaborate prompts
• Move forward: Fix issues instead of reverting
• Build for agents: Structure code so AI can navigate it easily
• Add humanity: Style, delight, and taste are your job
• It's a skill: Like an instrument, it takes practice to master

The future of coding isn't about writing code. It's about directing capable AI agents while bringing the human elements they can't provide.

And that future is already here.