AI Coding Agents: An Overview

Intermediate · 38 min

A survey of Claude Code, Cursor, Copilot, Codex, and Gemini CLI, and how terminal vs IDE agents differ in autonomy and strengths.

Before thisReading and Debugging Generated Code

Theo - t3.gg · 38 min

AI Coding Agents: An Overview

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by Theo - t3.ggReport a problem with this video
Not started
Set this lesson's status

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

  1. 01What'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.

  2. 02Why 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.

  3. 03Pick 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

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark