Continue.dev vs Cursor: does the OSS extension actually replace the fork in 2025?

Continue.dev is the most credible open-source attempt at building Cursor as a VS Code extension. The pitch: don’t fork the editor, just plug a high-quality AI assistant into the editor you already use, with full bring-your-own-model support and open-source transparency.

After three months running Continue.dev as my primary AI assistant inside vanilla VS Code (specifically to evaluate whether OSS could replace Cursor), the answer is: not yet, but it’s closer than most people think — and in the middle of Cursor’s 2025 pricing turbulence the calculus is different from what the marketing implies.

The YouTube voices framing this debate

Nathan Sebhastian’s “VSCode + Cline + Continue | NEVER PAY for CURSOR again” (12 min, 371K views, April 2025) is the most-watched take on the “don’t fork your editor” thesis. He walks through running Cline (the agent) and Continue (the chat/edit assistant) side-by-side inside stock VS Code, pointing them at a single API key, and shows the result is roughly Cursor-equivalent for routine work — with Cursor’s per-seat subscription replaced by metered API spend.

Cole Caccamise’s “The VS Code/Cursor Setup to INCREASE Productivity (2025)” (12 min, 271K views, February 2025) takes the opposite framing: he treats Cursor as the default and walks viewers through tuning the experience. Watching the two videos back to back is the cleanest way to see the actual choice you are making. Caccamise’s setup is faster to bootstrap and feels more polished out of the box. Sebhastian’s is more flexible and free of the per-seat tax once your usage scales.

Your Average Tech Bro’s “Goodbye Cursor, Hello Claude Code” (13 min, 213K views, July 2025) adds the third axis: the CLI route. He left Cursor for Claude Code (CLI, terminal-driven) entirely. This is the strongest pull-away from “AI inside VS Code” as the assumed model.

What Continue is

A VS Code extension (also available for JetBrains) that adds:

• A chat sidebar that talks to whichever LLM you configure
• Inline edit commands triggered from a keyboard shortcut
• Codebase indexing (with embedding-based retrieval)
• An autocomplete-style tab feature (using your configured model)
• A growing library of “slash commands” and “context providers” — the OSS analogue to MCP

It is genuinely OSS — Apache 2.0 license, code on GitHub, anyone can contribute. The team behind it is a real company, but the project is run as an open community.

Why this even matters

If you have followed the AI IDE space, you know the trade-off: Cursor and Windsurf are forks of VS Code. They are great but they are forks — meaning you lose the rolling stream of Microsoft VS Code updates (the fork has to catch up), some VS Code extensions don’t work the same way, and your editor is now a dependency on a commercial closed-source product.

Continue.dev is the bet that you can get most of what Cursor offers without the fork. Keep your VS Code (or JetBrains) installation, install an extension, configure your API key, work normally.

Where it actually delivers

Bring-your-own-model is best in class

You point Continue at any OpenAI-compatible endpoint, any Anthropic key, any local Ollama instance, any OpenRouter setup. The config is plain JSON. Switching models is a config-file change.

If you care about model flexibility — and especially if you want to route between expensive Anthropic for hard tasks and cheap DeepSeek for routine work — Continue is the cleanest implementation I have used.

Stays out of your way

The Continue UI is restrained. It does not redesign VS Code. It does not pop up suggestions you didn’t ask for. It is an extension that respects the editor it lives in. After Cursor, this can feel quiet at first, then refreshing.

True open source means you can audit

You can read the prompts Continue uses. You can see what data leaves your machine. You can fork it if the maintainers go in a direction you don’t like. For some engineers — especially in regulated industries or privacy-conscious individuals — this is the deciding feature.

Where it’s behind Cursor

The honest gap, mid-2025:

Tab completion quality. Continue’s autocomplete works but it does not feel like Cursor’s. Less anticipatory, fewer multi-line suggestions, slower in subjective latency. This is the biggest gap and the one most engineers will notice first.

Polish. The Cursor team has invested two years in tiny ergonomic improvements — the diff overlay, the keyboard flow, the way the chat sidebar interacts with the editor cursor. Continue does the same things, but each interaction is slightly more clunky.

Composer / multi-file edit. Continue can do multi-file edits via its agent mode, but the experience is rougher and the success rate noticeably lower than Cursor Composer.

Onboarding. Cursor is “install, sign in, type.” Continue is “install, decide on a model, configure an API key, read about context providers.” The activation energy is higher.

Where it actually beats Cursor

Three places, narrower but real:

No vendor lock-in. If Continue.dev raises prices or pivots, you keep your config and switch. With Cursor, you’re tied to whatever pricing model they land on — and as the r/cursor threads below show, that pricing has been moving.

Air-gapped / fully local workflows. You can run Continue with Ollama serving Qwen Coder or DeepSeek-Coder-V2 locally and never send code to a cloud LLM. Cursor can do this too via BYOK but the integration is rougher.

JetBrains users. Continue’s JetBrains plugin is actually serviceable. Cursor’s JetBrains story doesn’t exist (Cursor is a VS Code fork). If you’re a JetBrains shop, Continue is your only real first-class option.

The 2025 Cursor pricing exodus

The Reddit picture in mid-2025 is louder than the YouTube one. Two r/cursor threads define the mood:

“GOODBYE CURSOR” (324 ups) is the canonical leaving-the-platform post. The author lays out the math after the pricing changes and concludes the extension+BYOK route is now cheaper for their usage profile. The comments are split between “same, I’m out” and “what are you switching to?” — with Continue, Cline, Roo Code, and Claude Code all named multiple times.

“pricing is garbage” (184 ups) is the angrier version. The complaint there is less about the absolute price and more about predictability — quota changes mid-month, rate limits that don’t match what was advertised, and the feeling that the meter is moving under their feet.

On the r/ChatGPTCoding side, “Roo Code 3.20.0 release” (185 ups) is the parallel “the OSS alternatives are catching up” thread. Roo Code, Cline, and Continue are increasingly mentioned in the same breath as serious options rather than experiments.

The aggregate signal: 2025 is the year a meaningful chunk of Cursor’s power users at least tried the OSS extension route. Most of them came back. Some stayed. Almost everyone now has Continue or Cline installed as a backup.

Creator POV vs Reddit dissent

The YouTube creators are split cleanly. Sebhastian and the OSS-evangelist tier are pushing “you don’t need to pay Cursor”. Caccamise and the productivity-tutorial tier are still teaching Cursor as the default. Your Average Tech Bro and the CLI converts are arguing the whole “AI inside VS Code” frame is the wrong one and you should move to terminal-driven agents.

Reddit’s signal is more uniform than the videos suggest. The mood on r/cursor is “the product is good, the pricing is making me look at alternatives I would not have considered six months ago”. That is a meaningfully different statement from “Continue is now better than Cursor”. It is “Continue is now good enough that Cursor’s premium has to be justified, and Cursor’s pricing is making the justification harder.”

The wedge case worth naming: engineers who got annoyed by Cursor’s 2025 pricing changes and tried Continue as a cheaper alternative. Most of them came back to Cursor for the polish, a few stayed for the principle, and a non-trivial slice skipped Continue entirely and went to Claude Code in the terminal instead.

When to actually use Continue

Reach for Continue if:

• You are in JetBrains and want a real AI assistant
• You care about being able to audit or fork your AI tooling
• You want zero vendor lock-in on the editor itself
• You run local LLMs (Ollama, LM Studio) and want first-class support
• You are building a team policy that requires OSS dependencies

Stick with Cursor if:

• You value tab completion quality most
• You want the smallest activation energy
• You want the largest community and the most existing patterns to copy

Skip both and use Claude Code in the terminal if:

• You are comfortable in tmux / a real terminal already
• Your project is small enough that whole-repo context fits in the prompt
• You want the agent to actually do multi-step work, not just suggest edits

The bigger pattern

Continue.dev’s existence is good for the ecosystem regardless of whether you personally switch. It puts pressure on Cursor’s pricing. It keeps Cursor honest about lock-in. And as a hedge — a tool to have ready if Cursor stops being the right choice — it is the strongest OSS extension option in the space.

For us, Continue lives on my second machine as exactly that: a working alternative I keep configured. Cursor is still the daily driver because the autocomplete still wins, but I check in on Continue every couple of months and the gap is genuinely shrinking. Meanwhile Claude Code is eating the agentic-CLI lane next to both of them. The headline is that the OSS alternative is real, viable, and a meaningful presence in the AI coding tool landscape in 2025 — and the bigger story is that “AI inside your IDE” is no longer the only viable architecture.

See our Cursor vs Copilot piece for the broader IDE-extension comparison.