Move your team from Claude Code to GitHub Copilot.
Each person gets a short interview, then a personalized step-by-step guide showing exactly where their saved work, prompts, and projects land in GitHub Copilot — and the few things that need a manual step, walked through. You send one invite; nobody becomes the help desk, and nothing in Claude Code is changed or cancelled. Want to see where you’re paying for both first? Run the free audit.
The closest analog to Claude Code's default agentic loop (plan → tool calls → file edits → bash → iterate) is Copilot's Agent mode: select 'Agent' from the chat-mode dropdown in VS Code (also in Visual Studio and JetBrains). Agent mode plans multi-step tasks, edits across the workspace, runs terminal commands, and iterates until the goal is met — exactly like Claude Code, just embedded in the editor instead of running as a terminal app.
- Warning: Each Agent-mode turn consumes Copilot usage; as of 2026-06-01 monthly plans meter this as token-based AI Credits (annual Pro/Pro+ keep the legacy premium-request multipliers until renewal). Claude Code instead draws against your Claude plan's weekly hour caps with a rolling session window.
- Warning: Claude Code offers explicit permission modes (`default`, `plan`, `acceptEdits`, `bypassPermissions`) and per-tool allow/deny rules; Copilot Agent mode approves at the action level but does not expose a global plan-only mode.
- Warning: Claude Code has built-in sub-agents (Explore, Plan, general-purpose) that fork context; Copilot Agent mode runs as a single session.
Both products offer a 'cloud / repo-side' agent that opens PRs from a GitHub trigger. Claude Code ships an official GitHub Action (`anthropics/claude-code-action@v1`) you install via `/install-github-app` or by copying `examples/claude.yml`; it responds to `@claude` mentions in issues/PRs, runs scheduled jobs, and follows CLAUDE.md. Copilot's equivalent is the coding agent: assign an issue to Copilot on github.com (or launch from VS Code via `#copilotCodingAgent`, or from Copilot CLI) and it runs in a sandboxed Actions environment, makes commits on a branch, and opens a draft PR.
- Warning: Copilot cloud agent is plan-gated to all paid plans (Pro, Pro+, Max, Business, Enterprise, Students) — NOT on Copilot Free; Business/Enterprise also require admin enablement. Claude Code's Action requires an `ANTHROPIC_API_KEY` (or Pro/Max OAuth token via `claude setup-token`) plus the GitHub App.
- Warning: Claude Code Action runs YOUR workflow YAML — full control over runner image, secrets, and CLI flags via `claude_args` (including `--max-turns`, `--model`, `--allowedTools`, `--mcp-config`). Copilot coding agent runs an opinionated Actions environment you customize via repo policy.
- Warning: Claude Code Action also supports Amazon Bedrock and Google Vertex AI as model backends; Copilot coding agent uses GitHub-hosted models.
Copilot Spaces are shareable, github.com-hosted containers bundling code, docs, specs, snippets, and instructions to ground Copilot answers. Claude Code has no first-class equivalent: project context is assembled ad-hoc from CLAUDE.md, @-mentioned files, sub-agent MEMORY.md, MCP servers, and Skills. Migrants from Copilot Spaces typically replicate the curated-context bundle as a CLAUDE.md (or a skill folder under `.claude/skills/<name>/`) checked into the repo.
- Warning: Copilot Spaces live on github.com and auto-update when underlying files change. A CLAUDE.md is just a checked-in file — it does not pull in fresh content from other repos automatically.
- Warning: Org-owned Spaces can be shared with other organization members at an access level you choose (admin, editor, or viewer); the closest Claude Code analog is committing your `.claude/` directory (skills, agents, plugin pinned versions) to the repo so collaborators get the same context.
Claude Code has a rich extensibility stack — sub-agents (`.claude/agents/<name>.md` with isolated context, system prompt, tool allowlist, model, memory), skills (`.claude/skills/<name>/SKILL.md`, open Agent Skills standard), plugins (bundles of commands+agents+skills+MCP+hooks shipped through marketplaces), and lifecycle hooks. Copilot's extensibility is much narrower: MCP server support (in VS Code, JetBrains, Visual Studio, and Copilot CLI) plus legacy Copilot Extensions/skillsets. There is no Copilot equivalent of a delegated sub-agent or a per-skill model override.
- Warning: Claude Code's MCP host is a strict superset: in addition to user-added MCP servers, it ships a built-in `ide` MCP server bound to 127.0.0.1 with a per-activation token for native diff/diagnostics/Jupyter execution.
- Warning: Copilot enterprise admins can govern allowed MCP servers via policy; Claude Code MCP allowlists are per-skill or per-subagent via frontmatter, plus settings.json.
- Warning: Migrating Claude Code skills to Copilot usually means rebuilding them as MCP server tools or repo prompt files; there is no 1:1 mapping for sub-agents, plugins, or hooks.
Claude Code has a native VS Code extension (and installs in VS Code forks like Cursor, Devin Desktop, and Kiro via the Open VSX registry) plus a JetBrains plugin (beta) covering IntelliJ, PyCharm, Android Studio, WebStorm, PhpStorm, GoLand. Copilot's editor footprint is broader: first-party extensions for VS Code, Visual Studio, the JetBrains suite, Neovim/Vim, Xcode, Eclipse, and Azure Data Studio. Both share IDE diff viewers, selection/active-tab context sharing, and inline UIs.
- Warning: Copilot is the only option for Xcode, Eclipse, Neovim/Vim, and Visual Studio (Windows-only IDE) users today. Claude Code has no support for those editors as of 2026-05-27.
- Warning: Claude Code's CLI is the canonical surface and the VS Code extension lacks several CLI-only features (full `/`-command set, `!` bash shortcut, tab completion). Copilot's IDE features are the canonical surface and the CLI has the smaller feature set.
- Warning: The two install as independent VS Code extensions and ride alongside each other without conflict — a common setup is Claude Code for the agentic loop plus Copilot for the inline completion Claude Code does NOT provide.
Claude Code has no inline ghost-text completion product — its VS Code extension's own comparison table lists 'Tab completion' as CLI-only (and the CLI's tab completion is shell-style command completion, not editor ghost-text), and the agentic loop routes all code changes through Read/Write/Edit tools. Copilot's flagship feature is precisely this: inline ghost-text suggestions as you type, plus Next Edit Suggestions (NES) that chain follow-up edits. Migrants from Copilot who switch to Claude Code typically keep Copilot installed alongside specifically for the inline completion they lose.
- Warning: Because Claude Code emits no ghost-text, you can run it alongside a separate completion product (e.g., Copilot) — they install as independent VS Code extensions and coexist in the same instance without conflict.
- Warning: Copilot inline completion is included on every plan (Free capped at 2,000 completions/mo; paid plans unlimited) and is not metered as billable usage. Per GitHub's usage-based-billing docs, "Code completions and next edit suggestions are not billed in AI credits and remain unlimited for all paid plans," and they did not draw premium requests on the legacy model either.
- Warning: There is no path to get Claude Code to emit ghost-text completions — the architecture is fundamentally agent-loop based, not completion based.
Claude Code's primary surface is a terminal REPL launched with `claude`; Copilot's equivalent conversational surface is the Chat panel (Ask mode) inside VS Code, Visual Studio, JetBrains, Eclipse, Xcode, and on github.com. Both accept natural-language prompts and both have slash commands (`/help`, `/clear`, `/model` etc. on Claude Code; `/explain`, `/fix`, `/tests`, `/doc`, `/new` on Copilot). The mental model is the same (chat with the codebase), but Copilot Chat is editor-embedded while Claude Code Chat lives in a terminal you also point at a directory.
- Warning: Copilot Chat in IDEs is generally read-only by default for the workspace (it suggests; you accept) — to get an autonomous-editing experience you must switch to Edit mode or Agent mode.
- Warning: Claude Code's CLI offers shell-style tab completion, `!`-prefixed bash escape, and a richer slash-command set than Copilot Chat (e.g., `/cost`, `/usage`, `/permissions`, `/mcp`, `/agents`).
- Warning: Copilot Free includes only a small monthly usage allotment (chat/completions capped; historically ~50 chat messages/mo, now framed as a limited monthly AI-Credit allowance); Claude Code requires at least a paid Claude Pro plan (no free tier).
Claude Code limits the picker to Anthropic's frontier lineup (Opus 4.8, Sonnet 4.6, Haiku 4.5; bundled `opusplan` mode plans with Opus, executes with Sonnet) and lets you switch mid-session with `/model`. Copilot's Chat/Edit/Agent picker spans Anthropic Claude (Haiku 4.5, Sonnet 4.5/4.6, Opus 4.5/4.6/4.7/4.8, Fable 5), OpenAI GPT-5.x family, and Google Gemini (2.5 Pro, 3 Flash, 3.1 Pro, 3.5 Flash). As of 2026-06-01 Copilot moved monthly plans to usage-based AI Credits (token metering), so model choice now drives cost directly by tokens consumed; the legacy premium-request multipliers (e.g., Sonnet = 1x, Opus = ~15x, Haiku = 0.33x) survive only on annual Pro/Pro+ until term expiry. On Claude Code, model choice instead changes how fast you burn your plan's session/weekly Sonnet-vs-all-model caps.
- Warning: Copilot Pro+ is the only tier with full unconstrained access to all chat models; Pro/Business/Enterprise still see all models but premium ones consume premium-request allowance faster. Claude Code restricts model availability primarily by plan (Sonnet always; Opus disproportionately costly against quota).
- Warning: As of 2026-06-01 Copilot moved monthly plans to usage-based billing (AI Credits, token metering) and the multiplier table is retired for them — costs are directly proportional to tokens; annual Pro/Pro+ keep the legacy multipliers until renewal. Claude Code billing inside a plan stays time/session-based; only the API PAYG path is token-metered.
- Warning: Some Copilot models are preview-only or editor-restricted (e.g., GPT-5.4 nano is Codex VS Code extension and Pro+ only); Claude Code's picker is the same across surfaces.
For multi-file edit workflows, Claude Code uses its built-in Read/Write/Edit/MultiEdit tools driven by the agent loop and renders diffs in the terminal or in VS Code's native diff viewer (via the bundled `ide` MCP server). Copilot's equivalent is Edit mode: open Copilot Edits from the Chat menu, build a 'working set' of files, prompt, then review the proposed inline diffs and accept or discard them with the Keep / Undo controls (per-file or all at once). Both let you scope a multi-file refactor and review diffs before committing.
- Warning: Claude Code has a dedicated Plan mode (describe-then-approve) and code-state Checkpoints (rewind code / fork conversation). Copilot Edits has no equivalent checkpoint rewind — you rely on Git or editor undo to back out.
- Warning: Copilot Edits is available in VS Code, Visual Studio, and JetBrains; Claude Code's editing tools work anywhere (terminal) and the inline-diff UX is in VS Code and JetBrains extensions only.
- Warning: Copilot Edits counts as Chat usage; as of 2026-06-01 monthly plans meter it as token-based AI Credits (annual Pro/Pro+ still consume premium-request quota at the model multiplier until renewal). Claude Code editing draws against your Claude plan's session/weekly usage cap.
Claude Code is included in every paid Claude plan (Pro $20/mo, Max 5x $100/mo, Max 20x $200/mo, Team $20-25/seat, Enterprise $20/seat + usage); no free tier. Copilot tiers (verified 2026-07-04): Free, Pro $10/mo, Pro+ $39/mo, Copilot Max $100/mo (new highest individual tier), Business $19/seat/mo, Enterprise $39/seat/mo, plus free Student access. As of June 1, 2026, Copilot moved all plans to usage-based billing: each plan includes a monthly allotment of GitHub AI Credits (1 credit = $0.01), metered by token consumption at listed API rates — Pro 1,500 credits/mo (1,000 base + 500 flex), Pro+ 7,000 (3,900 + 3,100 flex), Max 20,000 (10,000 + 10,000 flex); Free gets 2,000 completions and Student unlimited completions (auto model selection only). Code completions and Next Edit suggestions stay free on all plans; credits do not roll over month to month. Claude plans instead cap by weekly usage windows (one all-model, one Sonnet-only) reset at a fixed weekly time.
- Warning: Copilot's billing migration completed on 2026-06-01: monthly plans are now usage-based (GitHub AI Credits, $0.01 each, token-metered, base + flex allotments where flex adapts to model pricing); the legacy premium-request model survives only on annual Pro/Pro+ until term expiry (with increased model multipliers from June 1), after which they drop to Free or convert to monthly with prorated credits. Plan migrants comparing older docs should price the usage-based state.
- Warning: Business ($19/seat) and Enterprise ($39/seat) prices are unchanged, but included AI-credit amounts ($30 and $70 per user/mo, pooled across the org) are promotional through August 2026 — reprice after that. Copilot code review consumes BOTH Actions minutes and AI Credits.
- Warning: Sign-up pauses persist: per GitHub's 2026-06-01 changelog, new sign-ups for Copilot Student, Pro, Pro+, and Max remain paused ('reopen in the coming weeks' — existing subscribers can still upgrade to Max); self-serve Business sign-ups for GitHub Free/Team orgs paused since 2026-04-22. No confirmed resumption as of 2026-07-04.
Claude Code's CLAUDE.md (project root, plus `~/.claude/CLAUDE.md` for user-level and `CLAUDE.local.md` for gitignored local notes) maps directly onto Copilot's `.github/copilot-instructions.md` (repo-level), `.github/instructions/*.instructions.md` (path-scoped), and per-IDE personal/global instruction files. Both are Markdown, both are auto-prepended to every chat/edit/agent request, and both honor a layering hierarchy.
- Warning: Claude Code loads CLAUDE.md files in scope order — managed/enterprise policy, then user (`~/.claude/CLAUDE.md`), then project, then local (`CLAUDE.local.md`) — concatenating them with later (more specific) files taking precedence, except the managed policy file which always applies and cannot be excluded. The docs recommend targeting under 200 lines per CLAUDE.md. Copilot honors all its instruction files together and suggests keeping instructions concise (its generator template targets "no longer than 2 pages"), warning that large files erode the context budget.
- Warning: Claude Code can read CLAUDE.md trees nested in subdirectories (loaded as you @-mention files in them); Copilot's path-scoped equivalent is `.instructions.md` files with `applyTo:` frontmatter.
- Warning: Copilot Spaces (see separate pattern) is a parallel context-grounding mechanism with no direct Claude Code equivalent — Claude Code grounds via CLAUDE.md, @-mentions, MCP servers, and sub-agents instead.
Both tools expose slash commands inside chat. Claude Code ships bundled skills (`/code-review`, `/debug`, `/batch`, `/loop`, `/claude-api`, plus `/run`, `/verify`, `/run-skill-generator`) and full session-control commands (`/clear`, `/compact`, `/context`, `/cost`, `/model`, `/usage`, `/permissions`, `/mcp`, `/agents`, `/plugin`, `/skills`, `/init`, `/review`, `/security-review`); Copilot Chat ships task-oriented commands (`/explain`, `/fix`, `/tests`, `/doc`, `/new`). The triggering pattern (`/`-prefix in the prompt box) is identical.
- Warning: Claude Code lets users define custom slash commands by dropping `.claude/skills/<name>/SKILL.md` files (or legacy `.claude/commands/*.md`) into the repo or `~/.claude/`. Copilot does not let you author custom slash commands the same way — the closest equivalent is `.prompt.md` prompt files that you invoke by name.
- Warning: Claude Code skills support YAML frontmatter for model overrides, allowed-tools, hooks, sub-agent forking (`context: fork`), and dynamic backtick-`!` shell injection; Copilot prompt files are simpler reusable prompts.
- Warning: Many Claude Code slash commands (`/cost`, `/usage`, `/permissions`, `/mcp`, `/agents`, `/plugin`) have no Copilot Chat equivalent — those operations happen in the IDE's settings UI or on github.com.
Claude Code IS a terminal app — `claude` launches the REPL and the built-in Bash tool runs commands subject to per-command allow/deny rules and permission modes (`default`, `plan`, `acceptEdits`, `bypassPermissions`). The terminal-native peer in the Copilot world is Copilot CLI: install with `npm install -g @github/copilot`, run `copilot` (interactive) or `copilot -p '<prompt>'` (programmatic). Both converse in natural language, propose and execute commands with explicit per-action approval, support MCP servers and custom instructions, and can launch cloud agents.
- Warning: Copilot CLI is included on every Copilot plan (including Free); Claude Code requires a paid Claude plan (Pro+) or API billing.
- Warning: Claude Code's permission model is more granular: per-tool allow/deny patterns in `settings.json` (e.g., `Bash(git commit *)`), pre-approve per skill via `allowed-tools` frontmatter, plus sandboxing mode. Copilot CLI relies on per-action approval prompts.
- Warning: Inside an IDE, Copilot also has a separate 'terminal chat' surface (Ctrl/Cmd+I in the integrated terminal) for natural-language command suggestions; Claude Code's equivalent is the JetBrains/VS Code extension which still drives the same underlying CLI agent.