Migrate from claude-code to github-copilot.
13 hands-on-verified translation patterns — what carries over and what to watch for. Cited to the Feature Parity Map; the audit tells you whether the move is worth it.
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 a premium request multiplied by the selected model's multiplier (request-based billing until 2026-06-01, then token-metered AI Credits). Claude Code instead draws against your Claude plan's weekly hour caps with a 5-hour 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 coding agent is plan-gated: Pro, Pro+, Business, Enterprise, Students — NOT on Copilot Free. 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: Spaces can be shared with org members via a URL; 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 works on Cursor/Windsurf/Kiro via Open VSX) 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: Both extensions ride alongside each other peacefully — Anthropic explicitly notes users often pair Claude Code with Copilot inline completion (which 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 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: Anthropic explicitly recommends pairing Claude Code with a separate completion product (e.g., Copilot) — the two coexist in the same VS Code instance without conflict.
- Warning: Copilot inline completion is included on every plan (Free capped at 2,000/mo; paid unlimited) and does not consume premium-request quota. NES is also free of premium-request cost.
- 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 caps Chat at 50 messages/month; 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.7, 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), OpenAI GPT-5.x family, and Google Gemini (2.5/3/3.1/3.5). On Copilot, model choice drives a premium-request multiplier (until 2026-06-01) — e.g., Claude Sonnet 4.5/4.6 = 1x, Claude Opus 4.7 = 15x, Claude Haiku 4.5 = 0.33x, Gemini 3.5 Flash = 14x, GPT-5 mini = 0x. 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: Starting 2026-06-01 Copilot transitions to usage-based billing (AI Credits, token metering) and the multiplier table goes away — costs become directly proportional to tokens. 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 accept (Tab) or reject (Alt+Del) inline diffs per-hunk. 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 and (until 2026-06-01) consumes premium-request quota at the selected model's multiplier; 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 has six tiers (Free, Student, Pro $10/mo, Pro+ $39/mo, Business $19/seat/mo, Enterprise $39/seat/mo). Per-seat Copilot is cheaper at entry but caps premium usage by request quota (Free 50/mo, Student/Pro 300/mo, Pro+ 1500/mo, Business 300, Enterprise 1000); Claude plans cap by weekly hours and a 5-hour rolling session window, with two weekly limits (one all-model, one Sonnet-only).
- Warning: Copilot is in the middle of a billing migration: request-based with model multipliers today, transitioning to usage-based AI Credits / token metering on 2026-06-01. Plan migrants should price both states.
- Warning: Self-serve sign-ups for Copilot Pro/Pro+/Student have been paused since 2026-04-20 and self-serve Business sign-ups for GitHub Free/Team orgs paused since 2026-04-22.
- Warning: Anthropic does not publish exact hour quotas for Pro/Max plans publicly — the source of truth is the in-app `/usage` and `/status` output. Only Team/Enterprise quota ranges (~50-95 h/wk Sonnet, ~3-7 h/wk Opus) have surfaced in support articles.
- Warning: Setting `ANTHROPIC_API_KEY` in Claude Code overrides plan auth and bills the API account at PAYG rates (Opus 4.7 $5/$25 in/out per MTok, Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5) — an option Copilot does not offer end-users.
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 applies a strict precedence (enterprise > project > user > local) and recommends keeping CLAUDE.md under ~200 lines; Copilot honors all instruction files together with no documented size cap but warns large files erode 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.