In the previous chapters, we put Claude Code, the flagship CLI agent, to work for real. But the world of AI coding has other powerful tools too. Cursor, GitHub Copilot, Codex — you have probably heard the names, yet how they differ and when to reach for each is surprisingly fuzzy. In this chapter we line these three up alongside Claude Code so that you can pick the right one for the job at hand.
Not "which is best," but "which one, and when"
Why learn more than one tool
You might think, "If I can use Claude Code, isn't that enough?" It's true that mastering one tool deeply matters. But each AI coding tool has a working style it excels at. Sometimes you want to hand off an entire large feature; sometimes you want to write carefully, checking one line at a time; sometimes you want to make partial edits while eyeing existing code — the nature of the work shifts from day to day. Knowing the character of several tools means you can pick the partner that fits the moment best, and combine them when needed. Thinking in terms of "the right tool for the job" rather than "which is superior" is the way to avoid detours.
💡 You don't need to master them all. The goal of this chapter is to understand where each of the four tools stands and fit them onto a single map. Once the names and personalities are in your head, when the need arises later you can instantly judge, "Ah, this is a job for Cursor." For now, just take a light look at the big picture.
Cursor — the AI editor you converse with while you watch
Cursor is an AI-focused editor built on top of VS Code, the standard code editor. It looks and feels almost identical to VS Code, with AI conversation and bulk-editing features deeply woven in. Because it understands the open file and the whole project as context, when you ask in chat "fix this function like so," it will suggest the relevant spot, show you the diff, and then apply it.
Its biggest appeal is the reassurance of talking with the AI while your eyes are on the code. The spot the AI is about to rewrite is highlighted in the editor, and you can review the before-and-after diff before taking it in. It feels less like "leave it all to me" and more like "editing side by side with the AI" — the more comfortably you read code, the more firmly you can hold the reins.
- Built on VS Code, so the switch is smooth (you keep your extensions and key bindings).
- You can review the diff before applying, making changes easy to follow.
- Good at bulk edits across multiple files and pinpoint instructions on a selection.
- When you want to make changes while looking over existing code.
- People used to working in a GUI editor who aren't comfortable with the terminal.
- Work where you polish the front end while checking the design and the screen.
📘 Learn more: Installation, pricing, and concrete usage are all covered in What is Cursor — the VS Code–based AI editor. As the top pick for the editor crowd, it's worth trying first.
GitHub Copilot — completion that suggests as you type
GitHub Copilot is the most widely adopted completion-style tool among AI coding tools. Built by GitHub and OpenAI, it plugs into many editors — VS Code and beyond — as an extension. Its most distinctive feature is autocomplete: as you start writing code, it anticipates the next likely line or block and suggests it in gray text. Press Tab to accept it as is, or ignore it and keep typing if you don't like it — that lightness is its charm.
In recent years it has grown beyond mere completion, adding chat and agent-like behavior. Still, Copilot's true forte remains the experience of "quietly suggesting from right beside you as you write." It doesn't break your rhythm of writing code yourself; it just takes over the boilerplate parts. You keep full initiative over the keyboard, and the AI stays a clever look-ahead assistant — that's the distance it keeps.
- Real-time completion that keeps up with your typing is fast and natural.
- Works with many editors, so the barrier to getting started is low.
- Write boilerplate and repetitive code with less typing.
- People who want to keep their own rhythm of writing code.
- When you want to quietly add AI to an existing development flow.
- Work where you want to churn out repetitive code quickly.
📗 Learn more: How it works, its plans, and the setup steps are explained in What is GitHub Copilot. For anyone who just wants to try out AI completion first, it's the lowest-threshold option.
Codex — OpenAI's autonomous agent
Codex is a coding agent offered by OpenAI. Its position is close to Claude Code: it's an autonomous type that, once you hand it instructions, will read and write files on its own, run commands, and even run the tests to drive the task forward. In addition to a CLI you can use from the terminal, it also comes in a cloud-hosted form, and its forte is taking on a whole chunk of work at once.
Where completion-style Copilot "stays close, one line at a time," Codex leans toward "handing off by feature or by task." Tell it "implement an API to this spec" or "fix this bug," and it will drive changes spanning multiple files from planning through execution in one go. Because it's built on OpenAI's models, another trait is that you can bring the strengths of the GPT family straight into your coding.
- A hand-it-all-off type that plans and executes tasks autonomously.
- The flexibility to run both as a CLI and in the cloud.
- Puts the broad knowledge of OpenAI's models to work in coding.
- When you want to hand off a whole feature in one go.
- People already comfortable with OpenAI/ChatGPT.
- When you want to compare it against Claude Code and switch between them.
📙 Learn more: Because Claude Code and Codex are both autonomous, it's a genuine toss-up. You can check the concrete differences in strengths and cost in Claude Code vs. Codex — a thorough comparison. Trying both and picking the one that fits your hand is a perfectly valid approach.
How they differ from Claude Code, and how to choose
Once you sort the four tools out, a single axis makes the view clear: "how far do you hand off to the AI?" They split into the autonomous type that takes on big jobs (Claude Code, Codex) and the companion type you write with while watching (Cursor, Copilot). Let's first look at them side by side in a table.
| Tool | Type | Main way to use it | Best-fit work |
|---|---|---|---|
| Claude Code | CLI agent (autonomous) | Instruct from the terminal and hand it off wholesale | Feature implementation, larger overhauls, automation |
| Codex | CLI/cloud (autonomous) | Hand off task by task, from planning to execution | Feature implementation, work in an OpenAI environment |
| Cursor | AI editor (companion) | Converse and bulk-edit while looking at the code | Tweaking and partially fixing existing code |
| GitHub Copilot | Completion (companion) | Suggests in real time as you write | Fast entry of boilerplate, hands-on coding yourself |
Boil this table down to a single question — "Right now, do I want to hand it off in one go? Or do I want to write while watching?" — and the choice gets much easier.
When you say "build this feature" and want it to carry implementation, fixes, and tests all the way through. Strong on substantial work and changes spanning multiple files. The human focuses on instructing and the final review.
When you want help through conversation or completion while following the code with your eyes in the editor. Suited to delicate work where you want to check line by line, and to situations where you want to hold the reins as you write.
💡 Neither is "better." The autonomous type moves fast, but hand off everything and your grasp of what's inside tends to slip. The companion type is easier to follow, but big jobs take more effort. The right answer is to move back and forth depending on the nature of the work. When you want to compare all four tools on one page, Cursor vs. Claude Code vs. GitHub Copilot vs. Codex — a thorough comparison comes in handy.
Using them together
We've been explaining "how to choose," but in fact you don't have to narrow it down to one. If anything, the more seasoned the developer, the more they switch tools by the situation. Tools of different types don't compete — they complement each other. Let's look at some representative combinations.
Write the details in Cursor, and send the bigger tasks to Claude Code. Throw "handle this bulk refactor" at the CLI, then review and fine-tune the returned diff in the editor. You get both the speed of handing off and the reassurance of reviewing and fixing.
Write briskly with Copilot's completion day to day, and send only the heavy implementations to an autonomous tool. Let Copilot take over everyday typing, and route substantial features to Claude Code or Codex. You get the fun of hands-on work and the labor savings both.
Pit Claude Code and Codex against the same problem and compare. Strengths and code quirks vary by model. When you get stuck with one, throwing it at the other can turn up an unexpected way through.
✅ Start with one, then add. You don't need to run everything in parallel from the outset. Keep Claude Code — the backbone of this course — at the center, and when you feel "I want to look at this in an editor and fix it," add Cursor; when you think "I'd like a bit of completion," add Copilot. Add one tool at the spot where you felt the friction — that's the way to expand without stumbling.
- Each tool has a working style it excels at. Choose by the right tool for the job, not "which is best."
- Cursor = the AI editor you converse with while watching / Copilot = completion that suggests as you write / Codex = OpenAI's autonomous agent.
- The one axis for choosing is "hand it off in one go (Claude Code, Codex)" vs. "write while watching (Cursor, Copilot)."
- You don't have to pick just one — combining is fine. Keep Claude Code at the center and add one tool at each spot of friction.
Once the map of tools is in your head, the next question is "how do you ask?" Even with the same tool, the way you phrase your instructions changes the result dramatically. In the next chapter, Chapter 4: "Asking well — vibe coding and spec-driven development," let's learn how to draw the results you're aiming for out of AI.