AI Coding Agents, Explained by a Dev Who Ships With Them

An AI coding agent is a program that takes a goal, pokes around your actual codebase, writes and changes real files, runs commands to check its own work, and loops on that until it thinks the job is done. That's the whole difference. Autocomplete finishes the line you're typing. A chatbot hands you a snippet to paste. AI coding agents go and do the thing across your repo, then come back and tell you what they touched.

I use them every day. Cursor and Claude Code have both shipped code that's live in apps I actually run, Apatero and Tool Index among them. I also spend a decent chunk of my week undoing things they got confidently wrong. So this isn't a hype piece and it isn't a takedown. It's what these tools are, mechanically, and how to drive one without wrecking your own project.

What You Get When You Search This

I checked the results for this before writing, same as I always do. It's a wall of "best AI coding agents" rankings. Cursor, Claude Code, Codex, Copilot, ranked and re-ranked mostly by companies that sell a competing tool. Faros, Vellum, a few others. There's a lone Reddit thread hanging near the top, which is just people asking each other the question the listicles didn't answer. Google's own AI summary now sits above all of them.

Almost none of them tell you what an agent is under the hood, or measure whether it's any good with a real number, or admit on the record where the thing fell over on them. One page comes close to explaining the concept and then stops right before any of the honest parts. That's the hole. I'm going to climb into it.

What An AI Coding Agent Actually Is

People throw around "AI coding agent," "AI coding assistant," and "AI chatbot" like they're the same product. They aren't, and the gap starts mattering the second you hand one write access to your files.

The cheap way to see it is by what each one is allowed to touch.

Autocomplete guesses the rest of a line. Useful, low stakes, been around for years. A chatbot in a separate tab can write you a whole function, but you're the one carrying it back into your project and wiring it in. An agent skips the carrying. It opens the files itself, edits several at once, runs the tests, reads the errors, and has another go. Anthropic describes Claude Code, one I lean on daily, as "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools." That "runs commands" part is the bit most people breeze past. The tool isn't suggesting. It's acting.

How They Actually Work

Strip off the branding and every one of these runs a version of the same loop.

It takes your instruction. It reads the relevant files to get its bearings. It makes a plan, sometimes one it shows you first. It edits code. It runs something, a test, a build, the app itself, to see whether the edit worked. It reads whatever came back, including its own error messages, and decides what to do next. Then round and round until it either finishes or gets stuck.

That last part is what makes it an agent instead of a fancy suggestion box. It observes its own output and reacts to it. GitHub's version, the Copilot coding agent, runs this loop off in its own throwaway environment on GitHub Actions, explores the code, makes changes on a branch, runs the tests and linters, then hands you a diff to look over before anything turns into a pull request. Claude Code does the same dance right in your terminal, and by default it stops to ask before it runs a command that could matter. You can switch that asking off. I mostly don't, for reasons the next couple of sections make obvious.

How Good Are They, Really

There's an actual test for this, which none of the ranking pages bother to mention. It's called SWE-bench Verified. Five hundred real bug reports pulled from open source projects on GitHub, each one a problem that human engineers confirmed is genuinely solvable. The agent gets the codebase and the issue, and it has to produce a patch that makes the project's own test suite pass. No partial credit for vibes.

The leaderboard moves every few weeks, so I'm not going to quote you a percentage that's stale by the time you read this. The useful takeaway is smaller than a number anyway. The best systems now solve a serious slice of real, messy, human-filed bugs, and they still whiff on plenty. Which is exactly what using one feels like.

What They Genuinely Do Well

Here's where I reach for one without hedging.

Boilerplate and wiring. A new API route, a form, the fortieth CRUD endpoint that looks like the previous thirty-nine. An agent bangs that out faster than I can type and gets it mostly right. Test coverage for code that has none, where I can eyeball the tests after. Long, tedious refactors that fan out across a lot of files, renaming one concept through an entire module, the kind of job that's not hard, just error-prone by hand. Chasing a bug when I can hand it the error and let it grep around on its own. Translating a chunk of code from one framework's way of doing things into another's.

Notice the pattern. It's all work where I already know what right looks like, so checking the output is quick. Tool Index, one of the apps I run, has a pile of endpoints and admin pages an agent helped stamp out. First sale on that project was a grand total of $29.99, roughly two months after launch, so nobody's buying a boat off this. But the plumbing the agent laid down held up fine, because plumbing is exactly the known-shape work these things are good at.

Where They Confidently Break Things

Now the other pile.

The failure that costs me the most time isn't the agent refusing to work. It's the agent being certain it succeeded when it didn't. A test was failing once, so it "fixed" the test by deleting the assertion that was catching the bug. Green checkmark. Bug still there, now with less coverage than before. I've watched that same move happen more than once.

Then there's scope creep. I ask for a one line change to a config value and come back to a diff where it refactored three files it decided were "related." Some of those edits are genuinely fine. One of them quietly broke something that was working. Now I'm doing archaeology on changes I never asked for.

It'll invent APIs, too. Call a method on a library that sounds like it ought to exist and doesn't, because a plausible-looking name is precisely what a language model is built to produce. And it has zero instinct for anything that isn't written down in the code. Whether a feature is even a good idea. Whether this architecture is going to hurt in six months. Whether the person paying actually wanted this. It'll implement a bad plan flawlessly and feel great about it.

None of that makes the tools useless. It makes them junior. Fast and tireless, occasionally brilliant, and badly in need of a review before anything they touch goes near production. If you want the tool-by-tool version of who breaks how, I put Cursor and Claude Code head to head in a separate piece.

Free, Paid, or Open Source

Going by the related searches, one thing the search page keeps asking is whether these are free or open source. Bit of both, honestly.

The heavy hitters are paid, usually a monthly subscription that buys you a budget of model usage. Several have a free tier that's real but capped, enough to get a feel for the thing, not enough to lean on all day. There are genuinely open source agents as well, Aider and Cline being two people mention a lot, where the agent software itself is free and you plug in your own model API key and pay for the tokens you burn. Cheaper on paper, fiddlier in practice, and you're still paying the model provider either way. I keep the actual current prices and who each one is for in the roundup of coding tools I actually keep rather than here, since pricing pages change faster than I can keep a blog post honest.

How To Actually Drive One

Most of the disasters above trace back to the same mistake, which is treating an agent like a vending machine. Type wish, receive feature, walk away. That's not the job. The job is closer to reviewing a fast, painfully literal junior dev who never gets tired and never pushes back.

A few things that actually move the needle for me.

Small steps beat big ones. "Build me the whole billing system" produces a confident mess. "Add a Stripe webhook handler for the invoice.paid event and a test for it" produces something I can check in two minutes. The narrower the ask, the smaller the blast radius when it's wrong.

Give it the context up front. What the project is, the conventions you use, the library you've standardized on. In Claude Code I keep that in a file the tool reads at the start of every session, so I'm not retyping it every time. Half the invented-API problem quietly disappears the moment the agent can actually see how the rest of your code already does the thing.

Read the diff. Every time. This is the part people skip and then blame the tool for. I read what it changed the way I'd review a pull request from a stranger, because functionally that's what it is. The times I've been burned are almost always the times I skimmed.

Make it prove the work. Tell it to run the tests, not just write them. Make it show you the thing actually working. An agent that has to satisfy a real check is a lot more honest than one riffing into the void.

That loop, small ask, real context, hard review, is also the backbone of shipping anything real with these tools, which I got further into in the walkthrough on building a SaaS with AI. The headline doesn't change, though. The agent does the typing. It does not do the judgment. That part is still yours, and pretending otherwise is how a one line config change eats your whole afternoon.

Where To Start

If you're new to all of this and the word "agent" still feels fuzzy sitting next to "vibe coding" and the rest of the buzzwords, I wrote a plainer starting point on what vibe coding even means. Read that, then come back and turn one of these things loose on a small, boring task you'd hate to do by hand. Watch it work, read what it did, fix the one thing it got wrong. You'll learn where the edges are faster that way than any ranking listicle will ever teach you.