Continue.dev Is Shutting Down: The Migration Guide for Displaced Users

Published June 23, 2026 by Pondero Reviews

Here is the short version, because the clock is the story. If you ran Continue for bring-your-own-key completions or local models, switch to Cline. If you lived in JetBrains, GitHub Copilot is the safe landing and Cline is the open-source one. If you want the most capable replacement and the bill is secondary, Cursor is the obvious move, since Cursor is the company that bought Continue in the first place. Export your data before July 15 or it is gone. The rest of this guide is the reasoning behind each of those picks.

What actually happened

Around June 16, Continue replaced its homepage with a short note: the company has been acquired by Cursor (per continue.dev). No press release, no transition plan, no "Continue lives on as a Cursor feature." The product is being wound down.

The mechanics are blunt. The homepage FAQ says existing users have until July 15 to export their data before it is deleted, and recurring billing has already been switched off, as The New Stack reported on June 22. The continuedev/continue repository is now read-only and "no longer actively maintained," per the GitHub repo banner. That repo carries 34.3k stars and 4.8k forks, so the displaced user base is not small.

This reads like an acqui-hire. The New Stack frames it that way, calling it "a quiet acqui-hire that shuts down the product and hands the codebase to the community," and notes the deal closed around the same window SpaceX confirmed it was buying Cursor for $60 billion. Continue's founders, Ty Dunn and Nate Sesti, built a genuinely good open-source agent. The code stays public under Apache 2.0. The hosted service, the accounts, and the roadmap do not.

So you have a decision to make in the next few weeks. Two decisions, really: export now, and pick a replacement that matches the specific thing Continue did for you.

First, figure out what you used Continue for

Continue covered three different jobs, and people leaned on it for one or two of them, rarely all three. Naming which job is yours is the whole decision.

The bring-your-own-key, bring-your-own-model job. This is the reason a lot of people chose Continue over Cursor or Copilot. You pointed it at your own Anthropic or OpenAI key, or at a self-hosted endpoint, and paid token cost instead of a per-seat subscription. No prompt left your network if you did not want it to. If that control was the draw, you need a replacement that does BYOK natively, not as an afterthought.

The cross-IDE job. Continue ran in VS Code and across the JetBrains family. Plenty of teams picked it precisely because Cursor is VS Code only and a chunk of the team lives in IntelliJ, GoLand, or PyCharm. If you are a JetBrains shop, your shortlist is short, because most of the polished replacements do not run there.

The agent-and-chat job. Codebase-aware chat, custom slash commands, an agent that edits across files. This is the most-replicated job in the category. Almost every tool below does it now, so this one rarely decides the pick on its own. It is table stakes.

Pin your job. Then read the matching profile.

If you used Continue for BYOK and local models: Cline

This is the cleanest swap, and the pick is Cline.

Cline is the closest thing to a like-for-like replacement. It is an open-source coding agent under Apache 2.0, the same license Continue used, with the GitHub repo public and active rather than frozen. The model story is the part that matters: Cline runs against Claude, GPT, Gemini, a local Ollama or LM Studio model, or any OpenAI-compatible endpoint, with bring-your-own-key or your own weights, per cline.bot. That is the Continue value proposition, intact. You keep paying token cost instead of a subscription, and a self-hosted prompt still never leaves your box.

The reach is real, not a launch claim. Cline's own site reports more than 8 million installs across platforms and 250+ contributors (cline.bot, checked June 2026). It ships as a VS Code extension, a CLI, and a terminal agent, and it speaks MCP for custom tools. For a developer who chose Continue to avoid vendor lock on the model, Cline asks you to change almost nothing about how you think.

The candid con: Cline is an extension and an agent runtime, not a polished forked editor. If part of what you wanted was a tighter, more opinionated UI, you will not find it here. Cline rewards the same tinkerer Continue did. You configure the provider, the keys, the rules. That is a feature if model control was your reason for being on Continue, and a chore if it was not.

Pricing is the easy part: the agent is free and open source; you pay only the model provider you point it at, or nothing if you self-host (per cline.bot). For a BYOK refugee, that is the same bill you already had.

If you used Continue because you live in JetBrains: Copilot, or Cline

This is the hard profile, because the JetBrains constraint kills most of the obvious answers. Cursor is a VS Code fork and does not run in IntelliJ. Windsurf is the same shape. So the two real choices are GitHub Copilot and Cline.

For most JetBrains teams, Copilot is the pragmatic pick. It has a first-party JetBrains plugin, it is backed by a vendor that is not going anywhere, and the pricing is the lowest entry point in this guide: a free tier, Pro at $10 per user per month, Pro+ at $39, and Max at $100, per github.com/features/copilot/plans (checked June 2026). Copilot now does model selection and agent workflows inside the IDE, so the agent-and-chat job is covered. If your team already runs on GitHub, the org billing and native PR integration close the deal on day one.

The candid con on Copilot for a Continue refugee is the one that stings: you lose the open model menu. Copilot routes through GitHub's backend and GitHub's bundled models. If you came to Continue specifically to keep prompts on your own infrastructure or to point at a self-hosted endpoint, Copilot does not give that back. The credit system is also worth reading before you commit; usage above the included allowance draws down credits at $0.01 each (per github.com/features/copilot/plans), so a heavy agent week can run past the flat fee.

That is exactly where Cline becomes the JetBrains answer for the BYOK crowd. Cline runs in JetBrains IDEs and keeps the open model menu Copilot takes away. The trade is the one from the profile above: less polish, more configuration. So the JetBrains pick splits on a single question. If you need self-hosted or arbitrary models, Cline. If you want the lowest-friction, lowest-cost, vendor-stable option and you are fine with GitHub's models, Copilot.

If you want the most capable replacement and cost is secondary: Cursor

If model control was never the point and you just want the most capable editor you can buy, the pick is Cursor, and there is a tidy reason: it is the company that acquired Continue.

Cursor is a forked VS Code editor (Anysphere owns it) with proprietary AI baked into the editor itself: a multi-file agent, codebase chat that fetches its own context, and a tab-complete model trained on code. It is the most polished tool in this comparison, and for a solo developer or a small team with no compliance constraint, the polish is the whole value. Pricing is a flat per-seat fee: Individual Pro at $20 per month, Teams at $40 per user per month, per cursor.com/pricing (checked June 2026). Model usage on the frontier models is folded into the plan rather than billed per token.

There is a real migration upside here too. Cursor reads .cursorrules files, and Continue's per-repo rules port over with little rework, so the rule set you built up does not get thrown away. If you were already eyeing Cursor and only stayed on Continue for the open-source principle, the principle just lost its product.

The candid con is the same one it always was, and the acquisition does not soften it. You give up model freedom. Cursor's prompts transit Anysphere's backend by design, because that backend is what makes the tab model and context retrieval fast. You pick from the models Anysphere bundles; you cannot point every prompt at your own VPC endpoint. For a regulated team, that is a hard stop, and it is the reason Cline exists on this list. The second con worth flagging: heavy agent days can blow past the included usage, the same pattern that bites on every usage-metered plan in the category.

If you want Cursor's shape without Cursor itself, Windsurf is the other VS-Code-fork option, now part of Cognition. It runs a free tier, Pro at $20 per month, and Max at $200 per month, with team plans at $80 per month plus $40 per full dev seat, per windsurf.com/pricing (checked June 2026). It is a reasonable Cursor alternative, but it carries the same architectural limit: a forked editor with a bundled model menu, no JetBrains support, no arbitrary self-hosted endpoint. It does not solve the Continue problem; it just gives you a second polished editor to choose from.

Export your data before July 15

The deadline is real and the consequence is deletion, so do this first regardless of which replacement you pick.

Open Continue's export flow from the homepage notice and pull everything down. Your local config is the part most worth saving. Continue's settings live in a YAML file in your home directory, typically here:

# macOS / Linux: copy your Continue config before the deadline
cp -r ~/.continue ~/continue-backup-$(date +%Y%m%d)
ls -la ~/continue-backup-*

# Windows PowerShell equivalent
Copy-Item "$HOME\.continue" "$HOME\continue-backup-$(Get-Date -Format yyyyMMdd)" -Recurse

That backup matters because your rules and slash-command definitions are portable. If Cline is your landing spot, install it and bring your provider keys straight across:

# Install the Cline CLI (per cline.bot)
npm i -g cline

# Point it at the same provider key you used in Continue
export ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_KEY>
cline

Continue's .continue/rules/ markdown files are plain prose constraints, and both Cline and Cursor read per-repo rule files of the same shape. Copy your rules directory into the new tool's rules location, restart, and most of your behavior pins carry over without a rewrite. If Cursor is your destination instead, the rules slot into .cursorrules at the repo root with little change. The model config does not transfer (different tools, different schemas), so plan to re-enter provider keys by hand in whichever tool you land on.

One sequencing note: do the export before you uninstall Continue. The extension can still read your local config after the hosted service goes dark, but once you remove it you are relying on the backup you took above. Take the backup.

Quick-reference comparison

Tool	IDE support	BYOK / own model	Pricing (checked June 2026)	Open source	Agent mode
Cline	VS Code, JetBrains, CLI	Yes, any provider incl. local Ollama / LM Studio	Free agent, pay model tokens	Yes, Apache 2.0	Yes
Cursor	VS Code fork only	No, bundled models only	Pro $20/mo, Teams $40/user/mo (cursor.com)	No	Yes
GitHub Copilot	VS Code, JetBrains, Visual Studio	No, GitHub-bundled models	Free, Pro $10, Pro+ $39, Max $100/user/mo (plans)	No	Yes
Windsurf	VS Code fork only	No, bundled models only	Free, Pro $20/mo, Max $200/mo (windsurf.com)	No	Yes

Pricing per cline.bot, cursor.com/pricing, github.com/features/copilot/plans, and windsurf.com/pricing, all checked June 2026.

The pick, by profile

The deadline forces the move, so make it deliberately rather than defaulting to whatever editor your loudest teammate likes.

BYOK or local-model developer: Cline. It is the only option here that keeps the model freedom that probably brought you to Continue, it is open source under the same license, and the bill stays at token cost. This is the swap that changes the least about your workflow.

JetBrains shop: Copilot if you want the lowest-cost, vendor-stable option and GitHub's models are fine. Cline if you need self-hosted or arbitrary models inside JetBrains and will trade polish for control.

Most-capable replacement, cost secondary: Cursor, the most polished editor of the four and the one your Continue rules port into most cleanly. Skip it if a compliance requirement means every prompt has to stay on your own infrastructure, in which case the pick flips back to Cline.

Whatever you choose, the one non-negotiable is the export. After July 15 the data is gone, and no amount of tool-shopping gets it back.

---

Related: Continue.dev vs Cursor · Cursor tool page · Cline tool page · Best AI coding tools