Cursor becomes code-completion champion

Cursor quietly acquired Continue_, the open-source alternative to GitHub Copilot. If you have been on the fence about which AI coding assistant to actually install on your machine, this is a story worth following. The combination pulls Continue’s open-source model (an early fork of StableCode-Instruct-v2-CodeLlama-34B, a 34-billion-parameter code-tuned language model) into Cursor’s editor, and the result is something I have been waiting for: a coding assistant you can run without sending every keystroke to a vendor’s cloud.

I am not going to tell you Continue is better than Copilot in raw benchmark terms. It is not. But the trade-off is more interesting than the marketing pages suggest, especially if you care about what happens to the code you write.

Why this matters for real developers

Most AI coding tools optimize for the demo. They show you a polished screenshot of a feature that worked once, on the developer’s machine, with a carefully chosen prompt. The actual experience of using one of these tools is mostly friction: you write a comment, the tool suggests code, you accept the suggestion, the suggestion is wrong, you undo it, you write a different comment, and so on. The difference between a tool you keep installed and a tool you uninstall after a week comes down to whether the friction drops or stays the same after the novelty wears off.

Continue’s design philosophy is closer to the friction-lowering end of the spectrum. It runs locally (with a local model) or against a server you control, and the suggestions are deliberately scoped to the file you are editing. It does not try to be a chat assistant, it does not try to refactor your whole repository, and it does not try to write tests for code that does not exist yet. It just suggests the next line or the next block, the way a senior engineer would when pairing with you.

Cursor’s acquisition changes the practical story because Continue has been a standalone tool. To use it, you launch Continue separately, type into its interface, and copy the suggestions back into your editor. That workflow works, but it adds enough friction that I know three developers who tried Continue and gave up because the copy-paste loop felt worse than just typing. Cursor is an editor, so integrating Continue into the editor itself removes the copy-paste step entirely. If the integration is well done (and Cursor has a track record of doing editor integrations well), Continue becomes a suggestion popup in the editor instead of a separate tool.

The trade-off you should know about

Continue runs on open-source models, and open-source models trail proprietary ones on benchmarks. Continue’s default backend is StableCode-Instruct-v2-CodeLlama-34B (a derivative of Meta’s CodeLlama model, fine-tuned for instruction-following on code). Copilot uses OpenAI’s Codex-trained models behind a closed API. The benchmarks on HumanEval (a standard test set of programming problems used to measure code-generation accuracy) and MBPP (Mostly Basic Python Problems, another standard code-generation benchmark) favor Copilot by a meaningful margin. In practice, that means Continue’s suggestions will be wrong more often, will require more editing, and will occasionally hallucinate functions that do not exist or use APIs that are not in your project.

For some developers, that trade-off is acceptable. If you are working on a private codebase that you cannot upload to a vendor cloud, the choice is between Continue with worse suggestions and Copilot with no suggestions at all. If you are working on open-source code that you would have uploaded to GitHub anyway, Copilot’s quality edge is real but not huge.

The bigger trade-off is about who owns the training pipeline. Continue’s models are downloadable, auditable, and modifiable. You can fine-tune them on your own codebase. You can see exactly what the model is trained on. Copilot’s training data and model weights are not disclosed, and the inference happens on OpenAI’s servers, which means your code (including any private business logic in the files you edit) flows through a third-party system. For most individual developers, that is fine. For developers at companies with strict data handling rules, it is not fine at all.

What onboarding looks like

Continue is easy to install. You can run it as a standalone tool (launch it, point it at a folder, start typing) or as a language server (a background process that follows the Language Server Protocol, a standard for editor-tool communication, so any LSP-compatible editor can talk to it) that hooks into VS Code, Neovim, JetBrains, or any editor that speaks LSP. The Cursor integration is the new option: install Cursor, install Continue from Cursor’s extension marketplace, and the suggestions appear in your editor without leaving it.

The offboarding story is also worth knowing. If you decide Continue is not for you, uninstalling it leaves no trace on your machine beyond the editor extension and any model files you downloaded. Your code is not uploaded anywhere. Your keystrokes are not logged. This is the privacy story Copilot cannot match, because Copilot’s architecture requires sending your code to OpenAI’s servers to generate suggestions. You can opt out of having your code used for training, but you cannot opt out of having it leave your machine.

What I would tell past me

If I could send a message back to the version of me that installed Copilot in 2022 and then uninstalled it six months later, I would say three things.

• The benchmark gap between Continue and Copilot is real but smaller than the marketing makes it sound. In day-to-day coding, the suggestions that matter are the ones in the language and library you are actually using, and on those Continue catches up faster than the headlines suggest.
• The privacy story is the actual reason to switch, not the open-source purity. Code is the artifact you spend the most time on, and it is worth knowing what happens to it.
• The editor integration is what determines whether you actually use the tool. A great model with a bad UX gets uninstalled. An okay model with a great UX gets used daily. Cursor buying Continue is the UX fix the open-source world needed.
• The model is downloadable, not leased. You can audit it, fine-tune it, or run it offline. That ownership matters more in five years than it does today.

Trade-offs

Cursor plus Continue is not free in quality. Suggestion accuracy is meaningfully lower than Copilot on the languages and libraries the benchmarks measure (Python, JavaScript, Go), and the gap widens for less common languages. If you are doing exploratory work where the suggestions need to be roughly right to be useful, Copilot is still the better tool.

The setup cost is real too. Continue’s model downloads are large (the 34B parameter model is about 70 GB on disk after quantization, the process of reducing a model’s numeric precision so it takes less memory while preserving most of its accuracy). Running it on a laptop with less than 32 GB of RAM requires running a smaller model, which compounds the accuracy gap with Copilot. If you do not have the hardware, the hosted Continue option exists but routes your code through their servers, which removes the privacy win.

For most individual developers on modern hardware, Continue via Cursor is the sensible default. For teams with strict data handling rules, it is the only acceptable option. For developers who need benchmark-leading accuracy on rare languages, Copilot is still the answer.

If you only do one thing from this article, install Cursor, install Continue from the extension marketplace, and try it on a real project for a week. The ten minutes of setup will tell you more about whether the tool fits your workflow than any review can.