Claude IDE Guide: VS Code, JetBrains, and Code Tools

Direct answer

Claude IDE usually refers to Claude Code working inside an editor, not a separate integrated development environment from Anthropic. The official routes are a native Claude Code extension for VS Code and compatible forks, plus a dedicated plugin for JetBrains IDEs. Developers in other editors can run the Claude Code CLI in an integrated terminal. Choose by editor fit, diff review, context sharing, permission control, and the workflow you can test safely.

Claude IDE decision summary

VS Code: use Anthropic's native extension for a graphical panel, plan review, inline diffs, file references, session history, and multiple conversations.
Cursor and VS Code forks: install the official extension when supported, or use Claude Code from the editor's integrated terminal.
JetBrains: use Anthropic's dedicated plugin for terminal launch, native diffs, selection context, file references, and diagnostic sharing.
Other editors: the CLI works in any terminal, but editor-specific context and native review depend on an available integration.
Teams: begin with normal or Plan mode, narrow context, repository instructions, and real test commands before increasing autonomy.
Tooling: built-in file, search, execution, and web tools cover most coding work. Add memory, skills, MCP, hooks, subagents, or plugins only for a defined need.
Main caution: editor access can expose selected text, active files, terminal output, configuration, credentials, and executable project files.

Is Claude Code its own IDE?

No. The Claude Code product is an agentic coding assistant available in a terminal, supported editors, a desktop app, and browser-based sessions. An IDE integration places its conversation, context, diffs, and controls beside the editor you already use. The compiler, debugger, language server, project model, and editor remain part of VS Code, JetBrains, or another development environment.

Compare official Claude Code surfaces and integrations.

Compare the official editor routes

VS Code extension: the richest documented graphical Claude Code experience. It includes the CLI and supports chat tabs, plans, diffs, attachments, history, settings, and extension commands.
Cursor: Anthropic links directly to a Cursor installation path for the official extension. Account, project, and extension policies still need team review.
Other VS Code forks: current docs name Windsurf and Kiro as examples. Availability can depend on the fork and the Open VSX registry.
JetBrains plugin: works with most JetBrains products, including IntelliJ IDEA, PyCharm, Android Studio, WebStorm, PhpStorm, and GoLand.
Terminal route: run the CLI from an editor terminal or external terminal. Start at the same project root so file context and commands match the open repository.
Unsupported editor UI: keep using the CLI rather than treating an unofficial extension as equivalent to Anthropic's maintained integration. Review third-party code and terms separately.

What does the VS Code extension include?

Anthropic describes the extension as the recommended Claude Code route for VS Code. Current prerequisites list VS Code 1.98.0 or higher and an Anthropic account. The extension includes the CLI, so advanced terminal commands remain available without installing a separate editor product.

Plans: review a generated plan as a Markdown document and add inline comments before work begins.
Context: attach files or folders, use fuzzy @-mentions, and share a selected line range from the editor.
Changes: inspect proposed edits in a side-by-side diff, accept or reject them, or modify the proposal directly.
Sessions: search local history, reopen conversations, and run several conversations in tabs, windows, or isolated worktrees.
Terminal: include selected terminal output in a prompt and switch between the graphical extension and CLI workflow.
Customization: access models, thinking, usage, memory, permissions, MCP servers, hooks, plugins, and Remote Control from the command menu.
Browser work: connect the documented Chrome extension and use an explicit browser attachment for web-app tests.

Check the current VS Code extension setup and feature reference.

What does the JetBrains plugin include?

The dedicated Anthropic plugin connects Claude Code to a JetBrains IDE. It can launch Claude, display native diffs, share the current selection, and insert file references. The plugin also passes IDE diagnostics such as lint or syntax errors.

Get the Claude Code plugin from JetBrains Marketplace and fully restart the IDE when required.
Run `claude` from the integrated terminal to activate integration features for the open project.
Use `/ide` from an external terminal to connect to the detected IDE and inspect connection status.
Start in the same project root as the IDE when Claude needs the same repository files.
Set the diff tool to automatic for native IDE diffs or terminal when that review path is preferred.
For remote development, install the plugin on the remote host according to the current documentation.
Treat WSL networking and firewall setup as an environment issue when IDE detection fails across the Windows boundary.

Check supported JetBrains IDEs, setup, diagnostics, and security notes.

How do the two JetBrains integrations differ?

JetBrains also documents Claude Agent inside JetBrains AI Assistant. That is a JetBrains-managed AI Assistant surface using an Anthropic coding agent. It is distinct from running the dedicated Claude Code plugin and CLI. Compare sign-in, subscription, provider, feature, policy, and support paths before standardizing on either route.

Anthropic plugin path: follows Claude Code installation, authentication, settings, and CLI behavior.
JetBrains AI Assistant path: follows JetBrains product availability, subscription, provider, and AI Assistant controls.
Evaluation rule: test the exact path the team will buy. Do not assume that a capability or privacy claim transfers between integrations.

Read the current JetBrains Claude Agent documentation.

Which Claude Code tools are built in?

The core agent combines the model with built-in tools for files, search, command execution, web access, planning, worktrees, skills, and other session actions. The exact tool set can change by version, surface, policy, and task. Treat the live tool reference and permission prompt as the source of truth.

Read and search: inspect files, find matching paths, and search text before changing code.
Edit and write: make targeted changes or create files within the allowed workspace.
Shell execution: run repository commands, tests, builds, formatters, version-control checks, and approved scripts.
Planning: explore in a read-focused mode and present an approach before implementation.
Worktrees: isolate tasks in separate Git working directories when the repository and surface support them.
Web access: retrieve current documentation or other approved online evidence when the environment allows it.
IDE bridge: receive diagnostics and editor context, open native diffs, or execute a confirmed notebook cell in VS Code.

Review the current built-in tool names and side effects.

Add extensions only when a need repeats

Anthropic's extension guide recommends starting with project instructions and adding other layers when a clear trigger appears. Extra integrations consume attention and context. They can also add network access, side effects, credentials, dependencies, and maintenance.

CLAUDE.md: persistent project conventions, commands, constraints, and source-of-truth notes loaded with a session.
Skills: reusable instructions or workflows loaded when relevant or invoked by name.
MCP: connections that expose external services, data, or actions as tools.
Subagents: isolated workers for focused research, review, or other context-heavy work.
Hooks: deterministic scripts, requests, prompts, or subagents triggered by lifecycle events.
Plugins: installable packages that can bundle skills, agents, hooks, MCP, LSP, and other configuration.
Agent teams: experimental coordination for independent sessions that need shared tasks and communication.

Use Anthropic's extension guide to match each layer to its trigger.

Set up the core CLI first with Better Design's Claude Code installation guide.

Choose a permission mode for the risk

Permission modes set a baseline, while rules can allow, ask, or deny specific tools. Start with default or Plan mode in a new repository. Increase edit or command autonomy only after the team has reliable tests, protected secrets, review, recovery, and a narrow task.

Default: reads run without asking while actions request approval. This is a practical starting point for unfamiliar work.
Plan: keeps exploration read-focused and presents a plan before changes. Use it for architecture, diagnosis, or unclear scope.
Accept edits: allows reads, file edits, and common file operations while retaining prompts for other actions.
Auto: allows broader action with background safety checks. Use it only after reviewing current behavior and repository controls.
Don't ask: runs only pre-approved tools. It can fit constrained scripts and controlled automation.
Bypass permissions: skips the permission layer. Anthropic positions it for isolated containers or virtual machines only.

Check the current permission modes before configuring the editor.

Control what the editor shares

IDE convenience can add context automatically. In VS Code, the active file path and current selection can accompany prompts while the extension is connected. JetBrains can share the selection, current tab, and diagnostics. Inspect the transcript or context indicator instead of assuming Claude saw nothing.

Exclude secrets, environment files, production exports, customer records, and unrelated confidential code with deny rules and repository hygiene.
Mention the smallest useful file, range, folder, error, log, or test rather than sending the full repository by habit.
Review terminal selections before attaching them because output can contain tokens, URLs, personal data, or internal infrastructure details.
Disconnect unused MCP servers and plugins. Each active connection increases capability, context, and operational risk.
Check which provider receives prompts and code when using Anthropic, Bedrock, Vertex AI, Foundry, or a JetBrains-managed path.

Review executable configuration as code

Anthropic warns that auto-edit permissions can let Claude change editor configuration files that the IDE may execute. Examples include tasks and settings. Use restricted or trusted-workspace controls, manual approval, protected paths, version control, and isolated environments for untrusted repositories.

Review changes to editor tasks, launch configurations, build files, hooks, package scripts, CI, and dependency sources.
Keep credentials outside the repository and restrict files that could expose them through selection or search.
Treat tool output, issue text, web pages, dependencies, and repository instructions as potentially untrusted input.
Run generated commands with the least privilege and avoid using an administrator shell for ordinary work.
Require tests, static checks, diff review, and human approval before a merge or deployment.

Use a small, verifiable setup path

Choose the exact editor route and confirm its current minimum version, supported operating system, account, provider, and policy requirements.
Install Claude Code or the official extension from the documented source, then confirm the displayed publisher and version.
Open a disposable or non-sensitive repository and sign in through the intended subscription or API provider.
Start in default or Plan mode and ask Claude to explain one selected function without editing it.
Request one small change, inspect the native diff, reject it once, then approve a corrected version.
Run the repository's own test, type, lint, and build commands. Compare the result with manual editor diagnostics.
Add a short project instruction file for verified commands and constraints, then restart to test loading.
Document updates, access removal, support, logs, provider routing, and recovery before wider rollout.

Score the workflow with representative tasks

Context accuracy: does the integration use the selected range, active file, project root, and diagnostics you intended?
Review quality: can a developer inspect plans, diffs, commands, test output, and discarded alternatives without losing context?
Control: can the team set permissions, deny sensitive paths, restrict tools, protect branches, and stop work quickly?
Editor fit: does it preserve navigation, debugger, language-server, test, refactor, and version-control habits?
Reliability: can sessions resume, survive extension updates, handle large repositories, and recover from connection failures?
Governance: are provider routing, data use, retention, cost, audit, access removal, and incident ownership clear?
Outcome: does a measured task finish with fewer defects and less review effort than the existing workflow?

Which Claude IDE route should you choose?

Choose the native VS Code extension when graphical sessions, plan comments, inline diffs, and extension commands matter. Choose the Anthropic JetBrains plugin when the team relies on JetBrains project intelligence and native diagnostics. Use the CLI when editor independence, scripts, remote terminals, or a minimal interface matter more.

Avoid choosing by demo speed alone. Run the same repository task through each shortlisted route. Measure context errors, changes accepted, tests passed, review time, security exceptions, usage, and recovery. Keep the editor where the team can understand and verify the work.

Frequently asked questions

Claude Code works in Cursor. Anthropic's current VS Code guide provides a direct installation route. The CLI can also run in Cursor's integrated terminal. Verify extension availability, publisher, account, and team policies before rollout.

Anthropic lists IntelliJ IDEA and PyCharm among the JetBrains IDEs supported by its dedicated plugin. Add the plugin, restart when required, and run Claude from the project terminal.

Supported integrations can provide diagnostics. The current VS Code IDE bridge exposes diagnostic retrieval. JetBrains documentation says lint and syntax errors are shared as you work. Test the exact language and project setup.

No. Built-in tools cover core coding work. MCP connects additional external services and capabilities. A connected IDE also runs a local bridge for specific editor features. Review each tool's source and side effects.

It increases the actions Claude can take without individual prompts. Use narrow tasks, trusted repositories, protected secrets, version control, tests, and review. Keep stronger permission bypasses inside isolated containers or virtual machines.

Yes. The Claude Code CLI works in any terminal. An unsupported editor may lack native diffs, automatic selection context, diagnostics, or maintained extension controls. Compare that tradeoff with the team's existing review workflow.

Connect Better Design