Claude Code + Cursor in 2026. How to Run Both in One Workflow

Are Claude Code and Cursor actually integrated

Short answer. There is no single Claude Code Cursor integration. There are two separate connection points, and conflating them is the most common mistake engineers make when they set this up.

Claude Code and Cursor are two distinct products with two different control models. Claude Code is Anthropic's agentic coding tool. Per the Claude Code overview, it "reads your codebase, edits files, runs commands, and integrates with your development tools" and is "available in your terminal, IDE, desktop app, and browser." Cursor is Anysphere's AI-powered IDE built as a VS Code fork. It describes itself as "your coding agent for building ambitious software" on the Cursor features page.

The two real connection points are these. Keep them separate.

• The Claude Code extension installs inside Cursor. Anthropic's VS Code extension docs ship a direct "Install for Cursor" link and note the extension "also installs in other VS Code forks" or via the Open VSX registry. This puts Claude Code inside the Cursor editor.
• Cursor can route to Anthropic Claude models. Separately, Cursor lets you pick Anthropic models from its own model picker for Cursor's Agent, Tab, and chat features. The Cursor features page lists models including Opus 4.8, GPT-5.5, Gemini 3.1 Pro, and Grok 4.3, plus an Auto option.

The distinction matters. "Does Cursor support Claude" is yes. But that is Cursor calling a Claude model for its own features. It is not the same as running Claude Code. The rest of this guide treats both, and shows where each one earns its place. For the full head-to-head on context, pricing, and tokens, see our Claude Code vs Cursor comparison.

The two control models you are combining

When you run both, you are combining two different answers to one question. Who holds the cursor.

Cursor is IDE-first. You drive, and the AI assists with completions and edits you approve inline. Claude Code is agent-first. You describe the outcome, and the agent plans, edits across files, and verifies. A third-party comparison from Builder.io frames it the same way. Claude Code is "describe what you want, the AI drives, and you review the results." Cursor is "you drive, the AI assists with completions, suggestions, and edits you approve inline."

Cursor. The editor you drive

• Tab next-action prediction. Per the Cursor features page, "Our specialized Tab model predicts your next action with striking speed and precision."
• Inline diffs and visual review. You approve edits as you go, inside a familiar VS Code surface.
• Multi-model routing. "Choose between every cutting-edge model from OpenAI, Anthropic, Gemini, xAI, and Cursor" (Cursor features).
• Codebase understanding. "Cursor learns how your codebase works, no matter the scale or complexity" (Cursor features).

Claude Code. The agent you brief

• Multi-file agentic work. Per the Claude Code overview, it plans the approach, writes code across multiple files, and verifies it works.
• Git and pull request automation. The overview names "git commits and pull requests" as native capabilities.
• MCP, memory, and sub-agents. The overview names Model Context Protocol connections, CLAUDE.md memory, skills and hooks, and sub-agents.
• Model choice via the CLI. Switch models with /model. The model configuration docs list aliases including opus, sonnet, haiku, fable, and opusplan.

The practical read. Cursor is where you make line-level decisions and approve diffs. Claude Code is where you hand off a brief and let the agent drive across the codebase and the terminal. Builder.io cites Claude Code for "autonomous multi-file refactoring across large codebases" and Cursor for "Tab completions with a specialized model for real-time inline editing predictions" (Builder.io). Treat those as framing, not benchmarks. No head-to-head speed numbers are claimed here because none are published in the sources.

How to run both in one workflow

Here is the source-supported setup. Four steps, and one config detail that trips most people on the first try.

1. Use Cursor as the editor. Drive inline edits, Tab completions, visual diff review, and codebase navigation in Cursor, per the Cursor features page.
2. Install the Claude Code extension into Cursor. Use the "Install for Cursor" link or the Open VSX registry, per the VS Code extension docs. The extension gives you "inline diffs, @-mentions, plan review, and conversation history" in a side panel, plus plan review before accepting, auto-accept mode, @-mentioning files with line ranges, multiple conversations in tabs, and checkpoints to rewind edits.
3. Install the standalone Claude Code CLI. This is the load-bearing detail. The extension bundles its own private copy of the CLI for the chat panel, but to run claude in Cursor's integrated terminal you need the standalone CLI installed separately. As the VS Code docs state plainly, "Installing the extension does not put claude on your shell PATH." Without this step, you get the side panel but not the terminal agent.
4. Share one config across both surfaces. The ~/.claude/settings.json, CLAUDE.md memory, and MCP servers are shared between the extension and the CLI, per the VS Code docs. One set of rules and tools applies whether you are in the panel or the terminal.

One state, two surfaces

The extension and the CLI share the same conversation history. Per the VS Code docs, "To continue an extension conversation in the CLI, run claude --resume." That means a session you start in the Cursor side panel can move to the integrated terminal without losing context, and the reverse holds too.

For the agentic side, you pick the model inside Claude Code with /model <alias>. The model configuration docs document opusplan, which uses Opus for planning and then Sonnet for execution, and note that on the Anthropic API opus resolves to Opus 4.8 and sonnet to Sonnet 4.6.

This dual-tool pattern is not exotic. Builder.io observes that "most power users end up using both," with Claude Code handling "autonomous multi-file work like refactoring, test generation" and Cursor managing "interactive editing, code review, and tab completions" (Builder.io). It is the same loop senior AI-native engineers run. For the deeper version focused on the Max plan, see our Claude Code Max workflow for AI teams.

When to hand off from Cursor to Claude Code

The skill is knowing which surface fits the task in front of you. The handoff is fast, because the two share history. The judgment is what separates engineers who own this loop from engineers who default to one tool for everything.

Hand off to Claude Code when

• The change spans many files or a large codebase. Builder.io cites Claude Code for "autonomous multi-file refactoring across large codebases" (Builder.io).
• The work is CLI-heavy. Git, Docker, and Terraform, plus the ability to "create commits and pull requests" directly, per the Claude Code overview and Builder.io.
• You need MCP tool access. Connections to external tools like issue trackers, chat, and custom tooling, per the Claude Code overview.
• You want parallel or long-running work. Sub-agents and agent teams for work that runs while you do something else, per the Claude Code overview.

Stay in Cursor when

• You want to approve edits line by line. Inline edits and Tab next-action completions, per the Cursor features page.
• You are iterating visually. Diff review and quick interactive iteration are where Cursor's editor-first model wins (Builder.io).

The mechanical handoff ties it together. Start a session in the Cursor side panel, then continue it in the terminal with claude --resume, per the VS Code docs. You are not restarting context. You are moving the same conversation to the surface that fits the next move. That is the whole point of running both instead of picking one. This is the operating rhythm FutureProofing.dev expects, not a tool preference.

What this dual-tool fluency looks like at the hiring bar

Reading a setup guide is not the same as living in the loop. The hiring signal is not whether a candidate has installed both tools. It is whether the Cursor plus Claude Code rhythm is already their default, on day one, with no ramp.

What that fluency looks like in practice, described qualitatively.

• They pick the surface without thinking about it. Inline edits and Tab in Cursor for line-level decisions. The terminal agent for multi-file work, git, and MCP-driven tasks. The choice is reflex, not deliberation.
• They brief the agent with intent. They scope a clear outcome for Claude Code, review the plan, and accept partial diffs. They do not paste vague asks and accept whatever lands.
• They push back on the AI. When the agent hallucinates an API or over-abstracts, they catch it and correct it. Senior judgment stays in the loop.
• They move state across surfaces. A panel conversation becomes a terminal session with claude --resume when the task grows. No lost context, no restart.

This is the bar FutureProofing.dev hires against. Every accepted engineer is Claude Code Max-fluent on day 1. Most clients sponsor a 20x Claude Code Max seat per engineer, and the engineer is productive on the Cursor plus Claude Code loop from the first sprint.

The selectivity behind that bar is the proof. FutureProofing.dev accepts 12 of every 2,000 candidates contacted monthly, through a 5-stage vetting process. Stage 4 is a live paired AI challenge inside Cursor and Claude Code, where the dual-tool rhythm is tested empirically, not self-reported. Stage 5 is the final filter, run personally by co-founder Jess Mah. No engineer joins the bench without clearing her bar. The result is embedded senior AI engineers who own this exact workflow on day one. Not engineers who would need a quarter to learn it.

Collection · Building an AI-Native Team (definitional)