What is agentic coding? (and how it differs from vibe coding)
In one sentence:Agentic coding is when an AI works through a task in a loop, reading your files, taking real actions, checking the results, and adjusting, instead of answering your prompt once and stopping.
What it actually is
Agentic coding is when the AI doesn’t just answer your prompt once and stop, it works through a task in a loop. It reads the files it needs to understand your code, decides what to do, takes a real action (edits a file, runs a command), looks at what actually happened, and decides what to do next, on its own, without you spelling out every step.
Think of the difference between asking for directions and hiring a driver. A single-shot AI gives you directions once, based only on what you typed, and it’s on you to check them against the actual road. An agentic one gets in the car: it checks traffic, takes a turn, notices a road is closed, reroutes, and keeps driving until you arrive, coming back to ask only if it hits a fork it can’t resolve alone.
This is also where “vibe coding” fits in, and it’s not the same thing. Coined by Andrej Karpathy in February 2025, vibe coding describes a style of directing an AI: you describe what you want in plain English and mostly go by feel, often without reading the diffs it produces. Agentic coding describes the mechanism underneath: the read-plan-act-check loop that lets a tool like Claude Code verify its own work instead of guessing. You can vibe code with an agentic tool by never checking the result, or use that same tool deliberately, reviewing every step. One is how closely you supervise, the other is what’s happening under the hood.
Why your AI just did this
When you ask Claude Code to “fix the login bug,” it doesn’t try to produce the whole fix from your one sentence. It reads the relevant files to see how auth actually works in your project, forms a plan, edits the code, then runs your test suite or build command to check whether the fix works. If a test fails, it reads the error output and tries again, looping until the tests pass, it hits a limit, or it needs a decision only you can make. One request can turn into a dozen visible actions: several file reads, an edit, a test run, another edit.
When you’ll run into it
- Claude opens files you never mentioned, one to find where a function is defined, another to see how it’s already tested elsewhere
- The transcript shows a sequence like “Reading src/auth.ts… Running npm test… 2 tests failing… Editing src/auth.ts… Running npm test again…” before a final “done”
- Terms like “Agent Mode” (Cursor), “agentic” (Claude Code’s own docs), or “autonomous mode” showing up in a tool’s settings or marketing
- A task takes longer and costs more tokens than expected, because the agent ran many tool calls in sequence, not one reply
- A quick question gets one short answer, but a fix request gets read/edit/test in a loop, same model, just switched into agentic mode for a task that needs it
What to check
- Confirm it actually ran your tests or build before claiming the change works, not just told you in prose that it “should” work
- Read the diffs it produces even when you didn’t write them yourself. Agentic doesn’t mean unsupervised
- Watch for a stuck loop, editing the same file repeatedly with no real progress, and interrupt it rather than let it keep burning tokens
- Make sure there’s a working test or build command for it to run. If that’s broken, it can’t check its own work and may report success on faith
- For anything risky (auth, payments, a database migration), ask for Plan Mode or manual review instead of letting the full loop run unattended
Say it like a dev
Instead of: “just make it work, I don’t need to see how” Say: “run the loop, but show me the plan and the test results before you call it done”
Instead of: “why did it touch five files for one bug” Say: “it’s tracing the bug through the codebase, that’s a normal agentic fix, not scope creep”
Instead of: “I vibe coded this whole thing” Say: “I let it run agentically on this one, tests passed, but I still haven’t reviewed the diff”
People actually ask
“What's the actual difference between vibe coding and agentic coding?”
Vibe coding is a way of working with AI: you describe what you want in plain language and go mostly by feel, often without reading the code it produces. Agentic coding is what the tool does under the hood: it reads files, plans steps, runs commands like tests, and loops based on what it finds. You can vibe code with an agentic tool by never checking its work, or use that same tool carefully and review every diff. One describes how closely you're supervising, the other describes the mechanism doing the work.
“Why does my AI keep opening files and running commands instead of just answering me?”
Because guessing a whole code change from one sentence is unreliable, it needs to see how your actual code works first. An agentic tool reads the relevant files, makes a plan, edits code, then runs your tests or build to check whether the change actually works, and repeats that loop if something fails. A plain chat model skips all of that and just hands you its best guess in one shot, untested.
“Is agentic coding the same thing as AI-assisted coding?”
No, they sit at different levels of autonomy. AI-assisted coding usually means autocomplete or single suggestions you accept line by line, you're still driving each change. Agentic coding means the AI drives a whole task end to end, reading, editing, testing, fixing, across many steps on its own, and only checks back in with you at a decision point or when it's done.
Related terms
Go deeper
Checked against
Glim can explain your sessions, live.
The app watches your coding agent and narrates it in plain words. Waitlist is open.