How to Switch from GitHub Copilot: Step-by-Step Migration Guide

Short answer: Switching from GitHub Copilot takes 15–45 minutes for most developers, not a full rebuild. If you're moving to a VS Code-based tool (Cursor, Devin Desktop — formerly Windsurf), your extensions, settings, and keybindings transfer automatically or via a one-click import. The real work is migrating your custom instructions (Copilot's .github/copilot-instructions.md → the new tool's rules format) and deciding whether to keep Copilot running alongside your new tool for its GitHub-native features. This guide covers the exact steps for each destination.

Before You Switch: Decide What You're Actually Solving For

The right migration path depends entirely on why you're leaving. These are different problems with different solutions:

Not sure which category fits? See our AI IDE vs IDE extension vs CLI agent breakdown first — it maps every tool type to the situations they solve best.

Step 1: Export What You Actually Need to Keep

Before touching any new tool, capture two things from your current setup:

1. Your extension list (if staying in a VS Code-based environment): run code --list-extensions in a terminal. This gives you a plain-text list you can reinstall from in any VS Code fork.
2. Your custom instructions: if you have a .github/copilot-instructions.md file (repo-level custom instructions), copy its contents — you'll remap this to whatever format your new tool uses.

Settings, keybindings, and themes carry over automatically when moving between VS Code-based tools (Copilot itself is an extension inside VS Code, so this applies whether you're moving to Cursor, Devin Desktop, or staying in VS Code with a different extension).

Migrating Your Custom Instructions: The Format Mapping

This is the part most migration guides skip, and it's the part that actually takes time. Every tool has its own file(s) for project-specific AI instructions — moving between tools means remapping, not copy-pasting.

The practical process: take your existing instructions file, adjust the header/formatting conventions for the destination tool, and reconcile any contradictions if you're merging multiple prior instruction sources. For a single, well-written instructions file, this takes roughly 15 minutes. If you have a large, sprawling instructions document (a "handbook" that accumulated over months), treat the split as a small refactor — break it into scoped, purpose-specific files rather than one giant block, since most newer tools (Cursor's .cursor/rules/, in particular) support multiple scoped rule files rather than one monolithic one.

Migration Path 1: Copilot → Cursor

This is the gentlest migration path since both are VS Code-based.

1. Download and install Cursor
2. On first launch, Cursor detects your existing VS Code installation automatically
3. Open Cursor Settings (Cmd/Ctrl+Shift+J) → General → Account → click "VS Code Import"
4. This pulls in your extensions, settings, keybindings, and themes in one step
5. Convert your .github/copilot-instructions.md into .cursorrules or the newer .cursor/rules/ format

The one-click import works for roughly 80% of setups without issue. The remaining 20% typically need manual fixes for extensions tied to remote SSH servers, DevContainers, or VS Code Insiders-specific configurations — budget about 30 minutes for edge cases if you have a complex remote-dev setup.

Note: Since Cursor is a VS Code fork, you can also keep the GitHub Copilot extension installed inside Cursor and run both side by side — some developers use Copilot for its GitHub-native features (PR summaries, Issues integration) while using Cursor's Composer for agentic work. See our full Cursor vs Copilot comparison for how the two divide labor.

Migration Path 2: Copilot → Devin Desktop (formerly Windsurf)

Similar process to Cursor, since Devin Desktop is also a VS Code fork.

1. Download Devin Desktop from devin.ai (windsurf.com now redirects here) and run the installer
2. Import your VS Code extensions and settings during onboarding, or manually via code --list-extensions output
3. Create a .windsurfrules file based on your Copilot instructions (the filename kept its original name despite the rebrand)
4. The free tier gives unlimited Tab autocomplete immediately — you can evaluate the agent (now called Devin Local, replacing the retired Cascade) before committing to a paid plan

See our Cursor vs Devin Desktop comparison if you're deciding between these two destinations — they're priced identically at $20/month Pro, so the decision comes down to agent autonomy vs step-by-step control.

Migration Path 3: Copilot → BYOK Extension (Cline or Kilo Code)

This path keeps you in VS Code (or JetBrains) but replaces the AI layer with a BYOK tool.

1. Install Cline or Kilo Code from the VS Code Marketplace (or JetBrains Marketplace for Kilo Code)
2. Generate an API key from your chosen provider (Anthropic, OpenAI, Google) and paste it into the extension's settings
3. Disable or uninstall the GitHub Copilot extension to avoid overlapping suggestions
4. Migrate instructions to .clinerules (Cline) or Kilo Code's rules format
5. Neither Cline nor Kilo Code provides inline autocomplete — if you need it alongside your BYOK agent, run Devin Desktop's free-tier Tab completion or JetBrains AI's free Mellum completions in parallel

Remember: neither Cline nor Kilo Code provides inline autocomplete at all — they're agents, not completion tools. Pair either with a separate completion source if autocomplete matters to you. See our full BYOK tools guide for the complete cost breakdown by model, and our Cline vs Aider comparison if you're also considering a terminal-first BYOK option.

Migration Path 4: Copilot → Claude Code (CLI Agent)

This is a different kind of migration — you're not replacing your editor, you're adding a terminal-based agent alongside it.

1. Install Claude Code via your terminal (subscription or API access)
2. Create a CLAUDE.md file at your project root, adapted from your .github/copilot-instructions.md
3. Keep Copilot (or another completion tool) running in your editor for inline suggestions — Claude Code has none
4. Use Claude Code's terminal session for the larger tasks: framework migrations, comprehensive refactors, multi-file feature builds

This isn't really an "instead of Copilot" migration — most developers who add Claude Code keep an editor-level completion tool running too. See our Claude Code vs Copilot comparison for exactly how the two divide tasks.

Migration Path 5: Copilot → Self-Hosted (Tabnine or Tabby)

Relevant if your motivation is data residency or compliance, not features or pricing.

1. For Tabnine: this is an enterprise sales process, not a self-serve install — Tabnine has no individual plan since 2025 (minimum $39/user/month, annual billing). Contact sales for deployment planning (SaaS, VPC, on-prem, or air-gapped).
2. For Tabby (free, self-hosted): you'll need a GPU server. Deploy Tabby, connect it to a local model (StarCoder 2, CodeLlama), and point your IDE's Tabby plugin at your internal server instead of Copilot's cloud endpoint.
3. Both replace only completions and chat — neither has GitHub Issues → PR automation, so budget for a workflow gap there if your team relies on that.

See our full Tabnine vs Copilot comparison for the deployment and compliance tradeoffs in detail.

Should You Cancel Copilot Entirely, or Downgrade and Keep It?

Many developers don't do a clean break — they downgrade Copilot to its cheapest tier and keep it for GitHub-native tasks (PR summaries, Issues-to-PR automation) while moving daily coding to a new primary tool. This hybrid approach is worth considering if:

• Your team's workflow depends on Copilot's Coding Agent (assign a GitHub Issue, get a draft PR)
• You want to test a new tool for a few weeks before fully committing
• Your organization's Copilot Business/Enterprise seat is managed centrally and not something you control

In this setup: keep Copilot Pro ($10/month) or Free for GitHub-specific features, and run your new primary tool ($20/month Cursor or Devin Desktop, or $0+API for BYOK) for everyday coding. Total cost is often still lower than Copilot Pro+ or Max alone, with better agent capability.

Common Migration Pitfalls

• Losing accumulated context. If you've spent months tuning Copilot custom instructions, don't just delete them — remap them to your new tool's format first, even if imperfectly. Re-explaining project conventions from scratch costs real time.
• Assuming full parity on remote/DevContainer setups. The VS Code Import feature (Cursor) handles ~80% of configurations cleanly; remote SSH and DevContainer setups are the most common source of the remaining edge cases.
• Forgetting inline autocomplete gaps. If you're moving to a CLI agent (Claude Code, Aider) or a pure agent extension (Cline, Kilo Code), you lose inline completions entirely unless you pair it with something else.
• Migrating without a pilot. For teams, pick one project or repo to migrate first rather than switching the whole organization simultaneously — this surfaces instruction-file conflicts and edge cases before they affect everyone.
• Not checking what's actually loaded. After migrating instructions, verify the new tool is actually reading your rules file — most tools have a diagnostics view or reference panel in chat responses showing which instruction files were loaded for that session.
• Following stale tool names or dead products. If a guide (including older versions of this one) references "Windsurf" as a currently-standalone product, note it's now Devin Desktop. If a guide recommends "Continue.dev," note that product was acquired by Cursor and shut down in June 2026 — see our full write-up.

FAQ

How long does it take to switch from Copilot to another tool?

For a VS Code-to-VS-Code-fork migration (Copilot → Cursor or Devin Desktop), most developers are functional within 15–45 minutes, including instruction file remapping. Complex remote-dev setups (SSH, DevContainers) can add another 30 minutes for edge cases. Migrating to a fundamentally different architecture (CLI agent, BYOK) takes a bit longer since you're also setting up API keys and reconfiguring your completion workflow.

Do my VS Code extensions transfer to Cursor or Devin Desktop?

Yes. Since both are VS Code forks, they support the standard VS Code extension marketplace. Cursor has a one-click "VS Code Import" that pulls in extensions, settings, and keybindings automatically. For Devin Desktop or manual transfers, run code --list-extensions to get your list and reinstall from it.

Can I use GitHub Copilot and Cursor at the same time?

Yes. Since Cursor is a VS Code fork, you can install the official GitHub Copilot extension inside Cursor exactly as you would in standard VS Code. Some developers run both — Copilot for its GitHub-native integration and Cursor's own Composer/Agent mode for multi-file work — though this means paying for both subscriptions.

What happens to my Copilot custom instructions when I switch?

They don't transfer automatically — every tool uses a different file format (Copilot: .github/copilot-instructions.md; Cursor: .cursorrules or .cursor/rules/; Devin Desktop: .windsurfrules; Claude Code: CLAUDE.md). You need to manually copy the content and reformat it for your new tool's conventions. For a single well-organized instructions file, this typically takes about 15 minutes.

What happened to Continue.dev as a migration destination?

Continue.dev was acquired by Cursor in mid-June 2026 and shut down — final release June 19, 2026, GitHub repository read-only, no further updates. It's no longer a viable migration target. See our full timeline and replacement guide — Kilo Code is the closest current BYOK option covering both VS Code and JetBrains.

Should I cancel Copilot completely or keep a downgraded plan?

It depends on whether your team relies on Copilot's GitHub-native features (Coding Agent assigning Issues to PRs, PR summaries). Many developers keep Copilot Free or Pro for those specific features while moving daily coding to a new primary tool — the combined cost is often still lower than Copilot's higher tiers alone, with better agent capability from the new tool.

Is switching away from Copilot reversible if I don't like the new tool?

Generally yes, with minor friction. Your Copilot subscription can typically be reactivated, and since most alternatives are VS Code-based, your extensions and settings remain compatible either way. The main friction is your custom instructions file, which you'd need to migrate back if you return to Copilot's format.

What's the biggest mistake teams make when migrating together?

Migrating the entire organization simultaneously without a pilot. Pick one project or team first, validate the instruction-file migration and workflow fit, then extract a validated baseline configuration as a shared template for the rest of the organization to adopt — rather than everyone improvising their own setup at once.

Is "Windsurf" still the right thing to search for?

The product still exists and works the same way — it's just called Devin Desktop now, following Cognition AI's June 2, 2026 rebrand. Old windsurf.com links redirect automatically, and the config filename (.windsurfrules) didn't change. See our July 2026 roundup for the full rebrand details, including the fact that the separate JetBrains plugin kept the "Windsurf" name.

Bottom Line

Switching from GitHub Copilot is rarely a full rebuild. If you're staying in the VS Code ecosystem (Cursor, Devin Desktop), most of your setup transfers automatically, and the real work is remapping your custom instructions file — usually 15–45 minutes total. If you're moving to a fundamentally different architecture (a CLI agent or BYOK extension), budget more time for API setup and decide whether you still need a separate tool for inline autocomplete. And you don't have to choose one tool forever — many developers keep a downgraded Copilot plan for its GitHub-native features while running their new primary tool for daily coding.

→ Browse the full directory to compare all 89 alternatives by price, IDE support, and migration friction. Not sure where to start? See our tool category breakdown first.