Claude Code IDE Integrations

Quick Answer

Claude Code runs from the terminal and works alongside any editor. The VS Code extension adds a sidebar and integrated terminal. The JetBrains plugin does the same for IntelliJ, WebStorm, and PyCharm. TLDR: install the extension, open your IDE terminal, run claude from the project root, and review diffs in your editor git panel as Claude works.

Summary of the 6 setup steps

1. Install Claude Code via npm globally
2. Install the VS Code or JetBrains extension
3. Open the project in your editor
4. Run claude in the integrated terminal
5. Review diffs in the editor git panel
6. Commit from the agent or the editor

How the integration model works

Claude Code is a terminal program, not an editor extension. It reads and writes files directly on disk, and your IDE also reads and writes files on disk. Both tools agree on the source of truth (the filesystem) and neither one fights the other as long as you do not edit the same file at the exact same moment. The IDE extensions that Anthropic ships do not change this model. What they add is ergonomic glue: a sidebar that renders the agent output, a keybinding to run a one-shot prompt on the selected text, a diff viewer that opens when Claude proposes an edit, and a chat history pane listing past sessions for the workspace. The net effect is that you get the best of both surfaces at once. Claude does large multi-file edits and command execution from the terminal half. You do precise cursor work, inline refactors, and visual diff review in the editor half. The combination saves 15 to 30 minutes a day once you are used to it.

VS Code extension

The official VS Code extension lives on the Marketplace under the name Claude Code. Install it from the Extensions panel. The extension adds a sidebar view and a handful of commands.

After installation, open a project and press the Claude icon in the activity bar. The sidebar shows a fresh session, hooked into the integrated terminal at the bottom. You can type prompts in the sidebar or in the terminal directly. Output streams to both.

The extension features 4 things you will use daily. First, a diff viewer that opens when Claude proposes an edit, with accept and reject buttons. Second, a selection prompt that runs Claude against a code region with one keybinding. Third, a chat history pane showing past sessions for the workspace. Fourth, a file picker that lets you drag a file into the prompt as a reference.

JetBrains plugin

The JetBrains plugin works on IntelliJ IDEA, WebStorm, PyCharm, GoLand, Rider, PhpStorm, and RubyMine. Install it from Preferences, Plugins, Marketplace. Search for Claude Code and install.

The feature set mirrors the VS Code extension. Sidebar panel, diff viewer, selection-to-prompt command, and chat history. Keybindings live under Keymap, Claude Code, and default to cmd-shift-enter on macOS for the selection prompt.

One difference: JetBrains IDEs have richer refactor tooling baked in. Let Claude propose the scope and the edit plan, then use the IDE refactor commands (rename, extract method, move class) to execute mechanical parts. The combination is faster than either tool alone.

Terminal-only workflow

You do not need any extension to use Claude Code with an editor. The terminal-only workflow is still the simplest: split your editor window, open a terminal pane, and run claude in the project root. The editor shows files and diffs. The terminal shows agent output.

Most developers use this pattern before trying the extensions, and many stay with it after. The extensions add polish but the terminal flow handles every core use case.

One quality-of-life tip: configure your editor terminal to use the same Node version as Claude Code. On nvm-managed setups, add an .nvmrc to the project and tell the terminal to run nvm use on open. This prevents the mismatch where Claude is installed under Node 20 but the IDE terminal falls back to Node 16 and fails to find the binary.

The open-in-editor pattern

One valuable workflow is having Claude propose edits and reviewing them in the editor diff viewer before accepting. In VS Code, the extension opens a diff tab automatically when Claude proposes an Edit or Write call. You scan the diff, hit accept, and the file saves. If you want to tweak the edit yourself, hit reject, type your own edit in the prompt, and Claude regenerates.

This flow is faster than reviewing edits in the terminal because a diff viewer surfaces syntax, structure, and context better than a plain-text diff.

For small edits, skip the editor and accept in terminal. For large multi-file edits, the editor review pays for itself within 3 or 4 files because mistakes get caught before they land.

Git integration

Claude Code commits through shell commands. The resulting commits show up in your editor git panel the same as any manual commit. There is no special integration needed to see what Claude did.

A clean pattern is to let Claude implement and commit, then use the editor git panel to review the commit history. VS Code git graph and JetBrains Git tool window both render this well. If the commit is wrong, reset and re-prompt.

A caveat: Claude and your editor can race on staging if you both stage files at the same moment. Easy to avoid by committing to one tool as the stager per session.

One-liner in IDE keybindings

A useful trick is binding a keyboard shortcut in your IDE that runs claude --print "task description" against the selected text. The --print flag makes Claude respond once and exit, without opening an interactive session.

Use cases: explain this function, generate a docstring for this signature, add type hints to this block, write a test for this module. The keybinding runs fast (3 to 8 seconds on Sonnet) and the output returns to the terminal or a new buffer.

VS Code settings support this via the tasks.json file. JetBrains exposes it through External Tools. Either way, once configured, a single chord fires a Claude task against the current selection.

Workflow patterns

Different tasks favor different surfaces. Here are the patterns that work in practice.

For large multi-file features, stay in the terminal session. The agent handles planning, reading, writing, and committing. You scan the diff in the editor once the work is done.

For small edits to a file you are already looking at, the selection prompt in the sidebar is fastest. Highlight the code, press the keybinding, type the change, accept the diff.

For debugging, split your attention. Claude runs tests and reads logs in the terminal. You inspect variables and set breakpoints in the IDE. Paste interesting log lines into the Claude prompt as evidence.

For refactors, use the IDE refactor tools for mechanical parts and Claude for the judgement-heavy parts. Rename in IDE. Change architecture via Claude.

When the IDE extension falls short

The extensions are good, not perfect. 3 common gaps.

First, MCP server management is still easier in the terminal than in the extension UI. Edit .claude/settings.json by hand for now.

Second, long-running agent sessions (over 1 hour) sometimes disconnect the sidebar view. The terminal session keeps running fine. Restart the sidebar to reconnect.

Third, subagent dispatch does not render cleanly in the sidebar yet. Subagents show as a single line with a collapse arrow, which hides the detail. Watch the terminal if you care about per-subagent progress.

None of these are showstoppers, and the fixes are simple. The overall integration still saves 15 to 30 minutes a day compared to pure terminal once you are used to it.

Setup checklist

A quick recap you can follow in 10 minutes. Install Claude Code globally via npm. Install the VS Code or JetBrains extension from the marketplace. Open the project. Run claude in the integrated terminal. Send a prompt. Accept or reject the diff in the editor. Commit. Close the session when done.

The whole setup is cleaner than most AI tooling. No login dance per session, no custom file format, no custom editor. Just your existing IDE plus a terminal agent that reads and writes files.