Agentic Coding > Vibe Coding

Two developers sit down with the exact same AI model and the exact same ticket: "add password reset to the app."

An hour later, the first one has a working feature - tested, scoped, and small enough to review. The second one also has something that "works," but they can't tell you how it works, why there are three new database tables, or which of the four sendEmail helpers actually fires. When it breaks in production, they'll be debugging code they've never read.

Same model. Same prompt budget. Opposite outcomes. The difference isn't the AI - it's how they drove it. One was vibe coding. The other was agentic coding. They are not the same thing, and the gap between them only gets wider as the stakes go up.

What vibe coding actually is

The term comes from Andrej Karpathy, who described it in early 2025: you "give in to the vibes, embrace exponentials, and forget that the code even exists." You describe what you want, accept whatever the model produces, paste errors back in without reading them, and keep going until it seems to work.

The defining move is accept-all. You don't read the diff. You don't hold a model of the code in your head. The AI is the author, the reviewer, and the QA - and you're the spectator nodding along.

And to be clear: this is genuinely great for some things. A throwaway prototype to test an idea. A weekend toy you'll never maintain. A one-off script to reshape a CSV. When the code's entire lifespan is measured in hours and nobody inherits it, not reading it is a perfectly rational trade. Vibe coding is fast, and for disposable work, fast is the only metric that matters.

The problem is that most code isn't disposable.

Where it breaks down

The moment code has to be maintained, vibe coding starts charging interest.

You have no mental model. When something breaks - and it will - you're a stranger in your own repo. You can't reason about a bug in code you never read. So you do the only thing you know how to do: paste the error back and hope. Sometimes the model fixes it. Sometimes it "fixes" it by adding a second bug that cancels the first.

The mess compounds. Each accept-all builds on the last un-reviewed change. The AI is now reasoning about its own untested output as if it were ground truth. Small wrong assumptions early become load-bearing later.

Picture the loop:

prompt → accept → "it works" → prompt → accept → "it works" →
prompt → accept → ❌ breaks → paste error → accept → ✅ "works"
                                            ↑
                          (a real bug got buried three steps back,
                           the "fix" just hid the symptom)

By the time you notice, the bug is four layers deep in code nobody understands. Security and correctness are the first casualties - the SQL string that's actually concatenated, the auth check that's subtly wrong, the race condition - because none of those announce themselves with a red error message. They just sit there until they don't.

What agentic coding is

Agentic coding uses the same models and the same agents. The difference is one role assignment: you stay the engineer, and the agent does the typing.

You don't ask for a vibe and accept the output. You run a loop:

Plan - decide what should change and roughly how, before any code is written.
Give context - point the agent at the right files, patterns, and constraints.
Review the diff - actually read what changed, every time.
Verify - run the tests, run the app, confirm the behavior.
Iterate - feed back what's wrong and tighten.

The same request looks completely different depending on which mode you're in:

# Vibe

"add password reset"

# Agentic

"Add password reset. Reuse the existing `sendEmail` helper in
lib/mail.ts and the token pattern from email verification in
lib/auth/tokens.ts. New route under app/api/auth/reset/.
Tokens expire in 1h, single-use. Add a test for the expiry case.
Show me the plan before you write code."

The second prompt isn't more code - it's more judgment, applied up front. You've told the agent which existing utilities to reuse instead of inventing new ones, where the code belongs, and what "correct" means. The agent still does the tedious part. You just refuse to hand over the part that requires actually understanding the system.

The line that matters: who holds the judgment

Strip away the tooling and the difference is one question: who is responsible for the decisions?

In vibe coding, judgment moves to the model. Whether the architecture is sound, whether the edge cases are handled, whether this is even the right thing to build - the AI decides by default, because nobody else is looking.

In agentic coding, judgment stays with you. The model is faster than you at typing, recalling APIs, and writing boilerplate - lean on that all day. But it is not accountable for the result. You are. When it ships, your name is on the PR, and "the AI wrote it" has never once made a production incident shorter.

The model is the better typist. You're still the engineer.

Doing agentic coding well

A few habits separate it from vibing with extra steps:

Plan before building. Make the agent propose an approach first. Catching a wrong direction in a plan costs one sentence; catching it in merged code costs a day.
Keep context tight. Point at the specific files and patterns to reuse. A focused agent reuses your sendEmail; a vague one writes a fourth one.
Review every diff. Non-negotiable. If you didn't read it, you didn't write it - you just inherited it.
Make tests the source of truth. "It works" from a model means "it ran." A passing test you wrote means it's correct. Trust the second one.
Keep tasks on a short leash. Small, verifiable steps beat one giant "build the whole feature" prompt you can't meaningfully review.

None of this is slow. After a little practice it's barely slower than vibing - and it's the difference between code you own and code you merely possess.

When vibe coding is actually fine

I'm not anti-vibe. There's a real place for it: prototypes you'll throw away, spikes to learn whether an idea is even worth doing, glue scripts, personal toys. When the code has no future and no audience, reading every line is wasted effort. Vibe away.

The mistake is letting prototype habits leak into production work - shipping the weekend-toy workflow into the codebase your team has to live in for the next three years.

What this means as a developer

Vibe coding and agentic coding both put AI at the keyboard, so they get lumped together. They shouldn't be. One is a prototyping mode - fast, disposable, judgment optional. The other is a way of building software - the agent multiplies your output while you stay the engineer who understands, decides, and answers for the result.

The teams that win with AI won't be the ones who let the model drive. They'll be the ones who learned to drive the model - plan, context, review, verify - and kept a human in the loop exactly where judgment matters.

Use the AI. Just don't hand it your job.

I write about AI tooling, full-stack development, and building in public as a CS student. Follow me on Twitter/X for more posts like this.