Migrating from GitHub Copilot

You have lived in GitHub Copilot for two years. Tab-complete is muscle memory, and it is genuinely good at finishing the line you were already typing. But the ticket on your board today is “migrate auth from sessions to JWT across the API and the React app” — and Copilot can only see the file your cursor is in. You end up opening fifteen files by hand, accepting suggestions one line at a time, and praying you did not miss an import. That is the ceiling you are hitting: Copilot completes code, but it does not plan, edit across files, run your tests, or own a multi-step change end to end.

This playbook moves you from completion to delegation. The three agentic tools — Cursor, Claude Code, and Codex — all read your whole repo, edit many files in one pass, run commands, and check their own work. You keep everything you like about Copilot and add an agent that handles the changes Copilot never could.

What You’ll Walk Away With

• A clear-eyed feature and pricing comparison of Copilot vs Cursor, Claude Code, and Codex (June 2026 numbers)
• A decision rule for which of the three agentic tools fits your workflow
• A phased migration plan that runs Copilot and your new agent side by side, with zero downtime
• Three copy-paste prompts that turn a Copilot-style task into an agent delegation
• The failure modes that bite Copilot migrants — prompt habits, context expectations, cost surprises — and how to recover

Copilot Is Not What It Was

First, recalibrate. The “Copilot is just 8K-context autocomplete” mental model is out of date. As of June 2026, Copilot’s base model is GPT-5.3-Codex, it ships a cloud agent and a CLI, and supported models can run with extended (1M-token) context. Copilot is a capable agent now.

So the migration is no longer “dumb autocomplete to smart agent.” It is a more honest trade-off: Copilot is excellent and cheap inside the GitHub ecosystem, while Cursor, Claude Code, and Codex each give you a deeper, more controllable agent loop and richer extensibility (MCP servers, skills, custom workflows). You are choosing the agent you want to drive, not escaping a toy.

Feature Comparison

Capabilities

Feature	GitHub Copilot	Cursor	Claude Code	Codex
Inline suggestions	Excellent	Tab completions	Via IDE extension	Via IDE extension
Multi-file edits	Yes (agent)	Yes (Agent mode)	Yes	Yes
Codebase understanding	Repo indexing	Full indexing	Agentic search	Repo-wide in sandbox
Default model	GPT-5.3-Codex	Your pick (Fable 5, Opus 4.8, Sonnet 4.6, etc.)	Claude (Opus 4.8 default; Fable 5 for peak complexity)	GPT-5.5
Context	Extended (1M-token option)	1M-token frontier models	1M-token (Claude)	1M-token (GPT-5.5)
Parallel/async tasks	Cloud agent	Background agent	Multiple terminal sessions	Built for parallel cloud tasks
MCP servers	Yes	Yes	Yes	Yes (CLI + IDE)
Agent skills	Limited	Yes	Yes	Yes

Pricing

Plan	GitHub Copilot	Cursor	Claude Code	Codex
Entry paid	Pro $10/mo	Pro $20/mo	Pro $20/mo (Claude Pro)	Included with ChatGPT Plus $20/mo
Power tier	Pro+ $39/mo	Pro+ $60/mo	Max $100-200/mo	ChatGPT Pro $200/mo
Team/business	Business $19/user	Teams $40/user	Individual plans	Business via ChatGPT
Billing model	Usage-based AI credits	Usage-based credit pool	Usage + Max tiers	Included in ChatGPT plan

All Copilot plans moved to usage-based billing on June 1, 2026: each plan includes a monthly AI-credit allowance (1 credit = $0.01) with the option to buy more. Cursor likewise runs a dollar-denominated credit pool per plan ($20 / $60 / $200) with unlimited Tab completions on every paid tier. Verify current numbers at each vendor’s pricing page before you commit budget — this market re-prices often.

User Experience

Aspect	GitHub Copilot	Cursor	Claude Code	Codex
Surface	IDE extension + CLI	Full IDE (VS Code fork)	CLI + IDE extension	App + CLI + IDE + Cloud
Learning curve	Minimal	Low (from VS Code)	Moderate (terminal)	Low-moderate
Project config	Repo custom instructions	.cursor/rules/	CLAUDE.md	AGENTS.md
Best at	Staying inside GitHub	Visual, interactive editing	Scripted/headless + deep analysis	Fan-out parallel tasks

Choosing Your Agent

You do not have to pick one forever — but start with one so the habit sticks.

Choose Cursor If...

• You want the smallest jump from a VS Code-style editor
• You like seeing diffs and accepting edits visually
• You want one model picker spanning Fable 5, Opus 4.8, Sonnet 4.6, Gemini 3.1 Pro, and more
• Inline Tab completion still matters to you day to day

Choose Claude Code If...

• You live in the terminal and want a scriptable, headless-capable agent
• You want deep, multi-step analysis with hooks and sub-agents
• You are comfortable steering via CLAUDE.md and slash commands
• You want to keep your current IDE and add an agent beside it

Choose Codex If...

• You want to fire off several independent tasks and review them later
• You already work through ChatGPT and GitHub, and want Codex App/Cloud
• You like async delegation over real-time pairing
• You want one config (AGENTS.md) shared across App, CLI, IDE, and Cloud

The Migration Workflow

The mindset shift is the whole game: stop describing the next line and start describing the outcome. With Copilot you typed a function signature and nudged the completion. With an agent you state the goal, the constraints, and how to verify it — then review the diff.

1. Keep Copilot on. Do not cancel anything yet. Leave Tab-complete running for the quick edits it is great at.

2. Pick one real task that Copilot can’t finish alone. A cross-file change is ideal: a feature touching several modules, a refactor, or a migration. This is where the value gap is obvious.

3. Write an outcome prompt, not a line prompt. Name the framework, the files or behavior, the edge cases, and the verification step (tests, type-check, lint). The prompts below are templates you can paste directly.

4. Review the diff like a PR. The agent will edit multiple files and often run your tests. Read every change, push back where it guessed wrong, and iterate in the same session.

5. Shift more work over each week. As you trust the agent on bigger changes, route routine multi-file work to it and keep Copilot for inline nudges. Cancel Copilot only once the new tool clearly carries its weight.

A concrete before/after

The Copilot way to add an avatar upload: type the route handler signature, accept completions line by line, manually wire validation, then open the test file and write cases by hand. Five files, a lot of typing, and you own every edge case yourself.

The agent way is one delegation. Here is the exact prompt, written for an Express + TypeScript backend:

Tip

Copy-paste prompt — ship a feature instead of autocompleting it (Cursor Agent):

“Add an avatar upload feature to the Express + TypeScript API. Add a POST /api/users/:id/avatar route that accepts a multipart image, validates MIME type (png/jpeg/webp) and max size 5 MB, stores the file via the existing storage service in src/services/storage.ts, and persists the returned URL to the users.avatar_url column. Return 400 with a typed error body on validation failure. Update the OpenAPI spec in openapi.yaml and add Vitest tests in tests/users.avatar.test.ts covering: valid upload, oversized file, wrong MIME type, and missing user. Run the tests and fix anything that fails.”

For a true cross-file migration — the task Copilot struggles with most — Claude Code’s terminal loop and CLAUDE.md context shine. Note how the prompt demands a rollback path, not just the change:

Tip

Copy-paste prompt — multi-file migration with a rollback plan (Claude Code):

“Migrate authentication from server-side sessions to stateless JWT across this repo. First, read the auth middleware, the login/logout routes, and the React auth context, and write a short migration plan to MIGRATION_JWT.md before changing code. Then: issue access + refresh tokens on login, verify the access token in middleware, add a /auth/refresh endpoint, and update the React client to store the refresh token in an httpOnly cookie and the access token in memory. Keep the existing session path working behind a AUTH_MODE env flag so we can roll back. Run the test suite, then add tests for token expiry and refresh. Summarize the rollback steps at the end.”

When the work is well-defined and you would rather not babysit it, hand it to Codex as an async task. Codex runs in its own sandbox with a full copy of the repo, so this is ideal for batch work you will review in a PR:

Tip

Copy-paste prompt — a well-scoped async task (Codex):

“In this repository, replace all uses of the deprecated moment library with date-fns. Find every import of moment, convert formatting/parsing/diff calls to their date-fns equivalents (preserving the existing display formats), remove moment from package.json, and update the lockfile. Do not change any behavior or output format. Run npm run type-check and npm test, fix any failures, and open the result as a single reviewable diff with a summary of every file you touched.”

Note

All three tools read MCP servers, so your database, GitHub, and docs integrations carry over. A Postgres MCP server lets the agent inspect your real schema before writing a migration; the GitHub MCP server lets it read the linked issue. Reusable workflows can also ship as agent skills installed across tools with npx skills add vercel-labs/agent-skills. See Migrating Between Codex, Cursor, and Claude Code for the exact MCP config in each tool.

When This Breaks

You write line-level prompts and get line-level results. The most common Copilot-migrant mistake is treating the agent like fancier autocomplete: “add error handling here.” Agents reward outcome prompts with constraints and a verification step. If results feel shallow, you are under-specifying — name the files, the edge cases, and how to check the work (see the prompts above).

You expect it to already know context Copilot inferred. Copilot quietly used your open tabs. An agent uses what you point it at plus its project config. If it edits the wrong module or invents an API, add a .cursor/rules/, CLAUDE.md, or AGENTS.md file describing your architecture and conventions, and @-mention or name the relevant files in the prompt.

The agent does too much in one shot. Going from one-line completions to a fifteen-file diff is jarring, and a wrong assumption now spans many files. Recovery: scope the first prompts to one module, review and commit, then widen. In Cursor lean on checkpoints; in Claude Code use Plan Mode (Shift+Tab) to approve the plan before any edits land.

The bill is bigger than $10 and you panic. Agent loops cost more than completion because they read, write, run, and re-check. Usage-based credits (Copilot, Cursor) make this visible. Recovery: route everyday work to a cheaper model (Sonnet 4.6 or Haiku 4.5), use Opus 4.8 for most agent work, and reserve Fable 5 / GPT-5.5 for genuinely hard changes (complex multi-file refactors, building from scratch, long-running tasks); most teams find the multi-file throughput pays for the tier within a sprint. See model comparison for current Claude pricing.

Tab-complete withdrawal. You will miss the constant inline suggestions in the first week. That is expected, not a defect. Keep Copilot enabled for inline edits while you build the delegation habit — there is no rule against running both, and Cursor’s Tab completion fills most of the gap if you switch fully.

What’s Next

Migrating Between Codex, Cursor, and Claude Code Translate CLAUDE.md / AGENTS.md / .cursor/rules and migrate MCP config across all three tools.

Migrating from Windsurf Moving from Windsurf to any of the three major AI coding tools.

Project Conversion Playbook Make your project AI-ready with proper configuration for all tools.

Cursor vs Claude Code A deeper feature-by-feature comparison to inform your choice.

For getting-started guides, see the Cursor Quickstart and Claude Code Quickstart. Questions land in the Cursor Forum and the Anthropic Discord.