Claude Code + GitHub Copilot in VS Code: setup and workflow for developers using both

Image: VS Code documentation overview card for GitHub Copilot in VS Code, used for editorial coverage.

What you’ll need

This guide assumes a working VS Code install, a terminal the reader is comfortable opening, and an existing GitHub account. It also assumes the reader already writes code where a single keystroke saved per line adds up over a working week.

The two tools serve different jobs. GitHub Copilot is the inline tab-completer that ships as a first-party Microsoft extension; readers who already type in VS Code have likely seen its grey ghost text. Claude Code is Anthropic’s agentic coding tool, which runs primarily in the terminal and gained an official VS Code extension that mirrors a chat panel inside the editor. Running both means a fast inline suggester for the next few lines plus a separate agent that can plan and edit across many files in one turn.

The walkthrough below targets developers on macOS, Linux, or Windows (via WSL) who want both tools active at the same time. Time required: roughly 30 minutes if both accounts already exist, closer to 60 minutes for a clean machine.

Why both, and when one is enough

Inline tab completion and agentic refactors are not the same kind of help. Copilot operates inside the file the cursor sits in, predicting the next token or block with sub-second response in most editor sessions. Claude Code runs as a separate process and works across files and shell commands until a task completes.

A typical session uses both. A developer types a function signature and accepts Copilot’s body completion, then asks Claude Code to rename that function across the repository and update the tests. Copilot earns its keep when speed-of-keystroke matters; Claude Code earns its keep when the task needs to traverse files or coordinate multiple steps.

A reader who only writes scripts in one language, or who wants the cheapest single subscription, should pick one. Copilot alone covers most short-context inline work. Claude Code alone covers planning and multi-file edits but does not give the inline tab-completion experience inside the editor.

Install Claude Code

Anthropic distributes Claude Code as a CLI plus a VS Code companion extension. The recommended install path is the native installer (no Node.js prerequisite), shipped via a one-line shell command that downloads the binary into the user’s home directory ¹ .

On macOS and Linux, run the install command from a terminal:

curl -fsSL https://claude.ai/install.sh | bash

On Windows, install from PowerShell:

irm https://claude.ai/install.ps1 | iex

After install, open VS Code and install the “Claude Code for VS Code” extension from the Marketplace ² . The extension auto-detects the CLI on the path and surfaces a Claude panel in the activity bar. First launch prompts an OAuth flow that signs the CLI into the user’s Anthropic account.

A login on the Pro plan ($20 per month) or Max plan ($100 or $200 per month, two tiers) routes Claude Code requests through the user’s plan quota; an Anthropic API key is the alternative for usage-based billing ³ . Pricing data fetched 2026-05-03 from Anthropic’s pricing page; prices fluctuate and verification at signup is sensible.

Install GitHub Copilot

Copilot is published by GitHub as a free VS Code extension, with feature gating against the user’s Copilot subscription tier ⁴ . Install path:

1. Open the Extensions view in VS Code (Cmd+Shift+X on macOS, Ctrl+Shift+X on Windows or Linux).
2. Search “GitHub Copilot” and install the extension published by GitHub. The companion “GitHub Copilot Chat” extension installs automatically as a dependency.
3. Sign in via the prompt that appears in the status bar, which opens a browser OAuth handshake against the user’s GitHub account.

Subscription tiers, as listed on GitHub’s plans page on 2026-05-03 (prices fluctuate; verify before paying): Copilot Free, which caps inline completions and chat requests per month; Copilot Pro at $10 per month (annual sign-ups were paused in the 2026-04-20 plan changes covered below); Copilot Pro+ at $39 per month; Copilot Business at $19 per user per month for organisations ⁵ . Verified students get the restricted Copilot Student plan at no cost through GitHub Education, which routes inline completions through Auto-mode rather than letting the user pick a specific premium model such as Claude Sonnet or Claude Opus ⁶ .

Two timing caveats matter for anyone subscribing in the next few weeks. GitHub paused new Copilot Pro, Pro+, and Student sign-ups on 2026-04-20 ¹¹ , and the published billing model for paid plans transitions to usage-based billing (monthly AI Credits replacing per-request limits) on 2026-06-01 per GitHub’s separate company-news announcement ¹² . Readers reaching this guide after either date should re-check the live plans page before paying.

The free tier suits readers who want to try inline completions before paying; the rate limits hit fast in a working session, so heavy daily use bumps into the paid tier quickly.

Image: Anthropic documentation card for Use Claude Code in VS Code, used for editorial coverage.

Sign in and verify both are alive

After both installs, the developer should see two distinct surfaces inside VS Code:

• A Copilot status icon in the bottom status bar, indicating an authenticated session and the current per-file activation state.
• A Claude panel in the activity bar (left side by default), with a chat input that streams output from the local CLI.

Sanity check: open any source file and watch for Copilot’s grey ghost text after typing a half-finished line. Then open the Claude panel and ask “list the files in this repo.” Both should respond. If either does not, the most common failure modes are an unsigned-in account or a corporate proxy blocking the OAuth callback.

Configure keyboard shortcuts to avoid conflicts

The two extensions ship default keybindings that overlap on Tab. The default Copilot accept-suggestion is Tab; Claude Code’s panel-toggle shortcut, by default at time of writing (2026-05-03), is Cmd+Esc on macOS or Ctrl+Esc on Windows or Linux. Verify the binding on the Claude Code extension page if a fresh install shows something different.

The fix is to keep Copilot on Tab (it is the dominant flow for most lines of code) and remap Claude’s panel-toggle to a less-trafficked combo. The cleanest way to find the exact command ID for the override is the Keyboard Shortcuts editor: open the Command Palette (Cmd+Shift+P or Ctrl+Shift+P), run “Preferences: Open Keyboard Shortcuts” (the visual editor, not the JSON one), search for “Claude Code: Focus Input”, right-click the entry, and pick “Copy Command ID”. Then run “Preferences: Open Keyboard Shortcuts (JSON)” and add an override using the copied ID ⁷ :

[
 {
 "key": "cmd+k cmd+y",
 "command": "<paste copied command ID here>",
 "when": "editorTextFocus"
 }
]

The chord above (Cmd+K then Cmd+Y) is not bound by VS Code’s default keymap or the Copilot extension, so the override does not silently displace an existing shortcut. Avoid Cmd+K Cmd+C for this purpose: that chord is bound by default to editor.action.addCommentLine, and overriding it removes a comment-line shortcut some developers rely on. Linux and Windows users substitute Ctrl for Cmd. The same panel exposes a search box for “claude-code” or “github.copilot” to find every command either extension registers; readers who want a different chord should pick one and confirm it does not appear in VS Code’s default keybindings list before saving the override.

Image: GitHub Copilot product page social card from github.com/features/copilot, used for editorial coverage.

Three workflow patterns that actually use both

The point of running both is not to use them at once on the same line. The point is matching the tool to the task within a single coding session.

Pattern 1: Copilot writes the body, Claude Code writes the test and runs the suite. Type the function signature; accept Copilot’s body completion; switch to the Claude panel and instruct it to write a test file for the new function and run the test suite. Claude Code edits the test file, kicks off the run, surfaces the failure if any, and proposes a fix.

Pattern 2: Claude Code refactors across files; Copilot fills in the small holes. Ask Claude Code to rename a class across the repository and update the type signatures in every consumer. After Claude finishes, the file the developer lands in often has small follow-up edits where Copilot’s inline completions handle the boilerplate (a missing import line, a default parameter).

Pattern 3: Copilot for the keystroke loop, Claude Code for the review pass. A developer finishes a feature and asks Claude Code to read the diff and flag anything that looks like a bug. Claude’s strength here is reading multiple files at once and reasoning about whether the code matches the stated intent.

Each pattern keeps the two tools on separate cognitive lanes. The shared rule: do not let Copilot’s inline suggestion fight with Claude Code’s open-file edits. If Claude Code is mid-edit on a file, close the file or pause Copilot for that buffer until Claude finishes.

Image: Anthropic announcement card for Claude Code on the web, used for editorial coverage.

Friction points and how to tame them

A handful of small frictions show up once both are active.

Inline ghost text fights with the chat-panel cursor. When the Claude panel is open, Copilot occasionally surfaces ghost text inside the chat input. The fix is to disable Copilot for the chat-input file type. Most developers ignore the cosmetic flicker, which is harmless.

File watchers and auto-stash. Claude Code may run git stash during multi-file refactors if the underlying agent decides it is the safest path. The cleanest workaround is committing the working tree before handing a multi-file task to Claude, so any auto-stash has a clean base.

Model-switching cost. Copilot lets the user pick a model (GPT family, Claude family, others) for chat; Claude Code uses Anthropic’s models exclusively. Developers who want Anthropic models in both surfaces set Copilot Chat to a Claude model and accept that Copilot’s inline completions remain on a separate completion model.

Cost framing

A developer running both at retail rates pays $30 per month: $10 for Copilot Pro and $20 for Claude Pro ⁸ . At roughly ₹95 to the dollar (RBI reference rate, 2026-04-30; verify the live INR-USD rate before budgeting) ¹⁰ , that is about ₹2,850 per month, or roughly ₹34,200 per year. Whether that pencils out depends on how many billable hours the tools save in a typical week.

Verified students get the free Copilot Student plan ⁹ , which drops the combined retail cost to $20 per month — though only if the student is comfortable with Auto-mode model routing instead of picking Claude Sonnet or Opus directly. The honest threshold: if a developer expects to ask Claude Code to do at least three multi-file tasks per week, the $20 is justified. Below that, Copilot alone or the API-billed Claude Code path with no monthly subscription is the cheaper run.

Who should skip one (or both)

A single-language scripter who works mostly on isolated files gets little extra value from the agentic surface. Copilot covers their day; the terminal-driven workflow Claude Code centres on is overkill.

A developer who never opens the terminal and relies on the VS Code GUI for everything will struggle with Claude Code’s natural home, which remains a CLI process even with the VS Code extension layered on top. Such a reader is better served by Copilot Chat alone, which is more GUI-native.

A student on the free Copilot Student plan who has not yet written code that benefits from agentic refactors should not pay for Claude Pro yet. Wait until a real refactor task arrives, then run a one-week API trial with a small budget to confirm the value before committing to the monthly plan.

Bottom-line workflow

Install Copilot first; it is the simpler setup and the lighter-weight surface. Add Claude Code when a refactor or multi-file task arrives that Copilot Chat alone cannot handle in one prompt. Configure the Cmd+K Cmd+Y chord (or its Ctrl equivalent) to keep the panel-toggle out of Copilot’s way. Match the tool to the task: Copilot for the keystroke loop, Claude Code for the multi-file pass.

The combination is worth running for developers who already work in VS Code and already feel the difference between “complete this line” and “rewrite this module.” For everyone else, one is enough.