AI Coding Agents: An Overview
A survey of Claude Code, Cursor, Copilot, Codex, and Gemini CLI, and how terminal vs IDE agents differ in autonomy and strengths.
AI Coding Agents: An Overview
The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.
Not started
What you'll learn
- An AI coding agent reads a real codebase, plans a change, edits files, and runs commands on its own — it's a step beyond autocomplete, which only suggests the next few lines.
- Terminal-based agents like Claude Code and OpenAI Codex live outside any one editor and work well for broad, multi-file tasks and anything scriptable from a shell.
- IDE-integrated agents like Cursor and GitHub Copilot keep the agent next to the code you're looking at, which suits tighter, file-scoped edits and fast visual review.
- Every tool sits somewhere on an autonomy spectrum between suggesting a diff for approval and running a multi-step plan unsupervised; the default position varies by tool and is almost always configurable.
- Picking a tool is less about which is "best" and more about which default workflow — terminal-first, editor-first, or chat-first — matches the task and how much you want to review before code lands.
From autocomplete to agent
A few years ago, AI help while coding meant autocomplete: a model guessed the next line or two, and you accepted or ignored it. An agent is a different kind of tool. It can read multiple files to understand how a codebase fits together, decide on a multi-step plan, edit several files in sequence, run a build or test command, look at the result, and keep going until the task looks done — all without you typing out each individual edit. That shift, from suggestion to action, is why these tools get called “agents” rather than “assistants,” and it’s also why they need guardrails: a tool that can run commands and rewrite files needs a clear boundary around what it’s allowed to do before you’ve looked at it.
Terminal-based agents
Claude Code and OpenAI’s Codex both work primarily from the command line. You point them at a project, describe what you want, and watch them read files, write diffs, and run shell commands in a loop, reporting back as they go. Neither is tied to a particular editor — you can run either from any terminal, pair it with whatever editor you already use, and drive it over SSH on a remote machine just as easily as on a laptop. That editor-independence makes terminal agents a natural fit for broad tasks: a refactor touching dozens of files, a new feature that needs its own test suite, or a migration that needs to run scripts and check their output along the way. Gemini CLI follows the same terminal-first shape — a command-line agent you converse with and direct against a live project — with the advantage of a very large context window for pulling in a lot of a codebase at once.
IDE-integrated agents
Cursor and GitHub Copilot take the opposite approach: the agent lives inside the editor, next to the code you’re already looking at. Cursor is a fork of VS Code with an agent (“composer”) built into the core experience, so prompting, diffing, and accepting changes all happen in the same window as your cursor and your file tree. GitHub Copilot started as inline autocomplete and has grown an “agent mode” that layers the same read-plan-edit-run loop on top of a familiar editor extension, usable in VS Code and other supported IDEs. The appeal of staying inside the editor is tight visual feedback — you see the diff exactly where the code lives, and jumping between “the agent’s suggestion” and “the rest of the file” costs nothing.
Autonomy is a dial, not a label
Every one of these tools sits somewhere on a spectrum between “propose a change and wait for my approval” and “run a plan across many steps with minimal check-ins.” None of them is fixed at one end. Claude Code and Codex both default toward more autonomy for terminal workflows but let you require approval before each file write or command. Cursor and Copilot default toward showing you a diff before it’s applied, but both support longer, more autonomous agent runs when you ask for one. The practical lesson is to treat autonomy as a setting you choose per task, not a fixed property of “which tool I picked” — a one-line config tweak is low-risk enough to hand off fully, while a change touching authentication deserves a tool set to show you everything before it commits to disk.
Matching the tool to the task
In practice, most teams end up using more than one of these. A terminal agent shines when a task is genuinely about the whole repository — tracing how a bug propagates across modules, or running the same transformation over fifty files. An IDE agent shines when you’re already deep in one part of the codebase and want quick, reviewable edits without losing your place. None of the five tools surveyed here — Claude Code, Codex, Gemini CLI, Cursor, and Copilot — is objectively ahead of the others for every job; they differ in where the agent lives, how much it does before asking, and how tightly it integrates with an existing editor setup, and the lessons that follow go hands-on with the two approaches you’ll meet most: a terminal agent (Claude Code) and an IDE-integrated one (Cursor and Copilot).
Check yourself
What's the core difference between a terminal-based agent and an IDE-integrated one?
A terminal-based agent like Claude Code or Codex operates from the command line against the whole project and isn't tied to a specific editor, while an IDE-integrated agent like Cursor or Copilot lives inside the editor window, with the agent's view scoped to what you have open.
Why doesn't "most autonomous" automatically mean "best"?
More autonomy means the agent does more before you see it, which is efficient for well-specified, lower-risk work but risky for anything where you want to catch a bad direction early; the right autonomy level depends on the task and how costly a wrong turn would be.
Pick one tool from this lesson — what's a task it tends to be strongest at?
Answers vary — for example, Claude Code is strong at large, multi-file terminal-driven tasks with heavy tool use; Cursor is strong at fast, visual, file-scoped edits reviewed inline; GitHub Copilot is strong at in-editor suggestions and agent-mode tasks tied closely to the open file; Codex is strong at autonomous, sandboxed multi-step coding tasks delegated from the CLI; Gemini CLI is strong at terminal-based tasks that benefit from a large context window.
Go deeper
Notes
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.