Run Claude Code alongside your editor

You just shipped a change from a bare terminal, and a reasonable worry is forming: am I supposed to abandon my editor for this? No. The whole pitch of this last lesson is that Claude Code is happiest sitting next to the editor you already use, and that it does a different job than the AI you already have in there. Get this placement right and the tool stops being a detour you context-switch into and becomes part of how you already work.

Two ways to put it next to your code

The lowest-friction option needs nothing new: open your editor’s integrated terminal and run claude in it, from the repo root, exactly as you did this whole chapter. Now the agent is one pane of the same window as your files, and on a supported editor it gets better than that — the edits it proposes show up as native diffs in the editor, the same red/green gutter you’d review a teammate’s PR in, instead of as text in the terminal. You review changes where you already know how to review changes.

The fuller option is the official VS Code extension or JetBrains plugin, which wires the two together more tightly — selection context, diff viewing, and a managed connection between the editor and the agent. Inside a session the /ide command manages that link:

/ide        # connect to (or check) the editor integration

The exact integration surface — which editors are supported, what each extension adds, the current keybindings — moves quickly, so the IDE integration docs are the page to trust for specifics. (One nice consequence for this audience: because Cursor is a VS Code fork, the same extension installs there too.) The durable point underneath the specifics: you do not run Claude Code in a separate window far from your code. You run it where your code already is.

It complements Copilot — it doesn’t compete with it

This is the reframe that matters most for anyone arriving from Copilot or Cursor. Those tools are autocomplete — they finish the line you’re typing, in the flow of your keystrokes, and they’re excellent at it. Claude Code is an agent — you hand it a whole task and it reads across files, makes a set of coordinated edits, and runs your tests. Those are different jobs, and they don’t cancel out:

• Keep your inline completion for the moment-to-moment typing — the function body you’re halfway through, the obvious next line.
• Reach for the agent when the unit of work is a task, not a line — “add this endpoint and its test,” “refactor this module,” “find why this test is flaky.”

You don’t choose between them any more than you choose between autocomplete and a code review. The engineer who gets the most out of this stack runs Copilot in the gutter for speed and Claude Code in the terminal for tasks, and lets each do what it’s good at.

The hour, closed

Step back and look at what the first hour actually contained. You installed the agent and learned that the directory you launch it in is the world it sees. You signed in and spent your first prompt on a question, watching it read before it answered. You handed it a real ticket and saw the read→act→check rhythm, with an approval checkpoint on every edit. You reviewed the diff instead of trusting the summary, learned that a bad run is one keystroke from undone, and committed the moment it was right. And now it’s sitting in your editor, next to the autocomplete you already had, doing the job autocomplete can’t.

That’s the foundation. Everything after this is refinement — more control over when it asks, more ways to plan and isolate work, more of its memory under your command. The natural next step is the one that turns a single good hour into a sustained working relationship: keeping a session alive and coherent across days of real work.