Developers argue about AI coding assistants the way other people argue about golf clubs or mechanical keyboard switches: everyone has strong opinions, and no two preferences look the same. But while Copilot and Cursor have grabbed most of the attention, a quieter project has been winning over developers who want more control. Its name is Continue.dev, and it is, in many ways, the anti-Copilot.
Instead of locking you into one model or a specific way of working, Continue.dev gives you a blank slate. You decide which large language model powers your autocomplete, your chat, and your code generation. You decide whether your code leaves your machine at all. And you don’t need an enterprise contract to try it. That flexibility has turned the project into a fan favourite for people who treat their editor as a deeply personal workspace.
What Exactly Is Continue.dev?
At its core, Continue.dev is an open-source extension for VS Code and JetBrains IDEs that brings AI into your coding workflow as both an autocomplete engine and a conversational assistant. It can read your current file, pull in relevant symbols from your codebase, and suggest edits that fit the surrounding style. The chat panel works like a context-aware pair programmer: you can ask it to explain a function, propose a refactor, or generate a test, and it can apply the result directly to your buffer.
Because the project is open-source and decentralised in its design, it does not funnel your prompts through a single vendor. That is a big deal for developers who work on proprietary codebases or who simply do not like the idea of a third party seeing every half-finished method they type.
Why “Bring Your Own Model” Changes Everything
The headline feature is that Continue.dev does not care which model you use. You can plug in OpenAI’s GPT-4o, Anthropic’s Claude, Google’s Gemini, or a local model served by Ollama. You can even swap between those providers depending on the task: running a low-cost local model for simple completions while saving the heavyweight cloud models for complex architecture questions.
That level of choice is rarer than it sounds. Most commercial AI coding assistants are locked to a single backend. If the vendor decides to change the model’s behaviour, deprecate an API, or adjust pricing, you live with it. With Continue.dev, the risk sits entirely with the provider you pick, and you can switch to another in a few lines of configuration. For developers keeping an eye on what free AI chat options actually offer in 2025, this flexibility also means you can easily pair Continue.dev with a free model like Llama 3.1 or Mistral on a local runtime if your hardware can handle it.
Key Features That Make It Worth a Look
Beyond model flexibility, Continue.dev ships with enough practical tools to compete with any commercial alternative. Here are the ones that tend to surprise new users:
- Codebase-aware chat: Ask questions about your whole project, not just the file you have open. The assistant uses embeddings to find relevant symbols and callers before composing a reply.
- Inline edits with diff preview: The “code” action can modify a whole block, underline the changes, and let you accept or reject them one hunk at a time.
- Custom slash commands: You can define your own commands, like
/cleanupto strip console logs or/docstringto add docstrings to the current function, and share them with your team. - Agentic background tasks: Headless “Continue agents” can run in the background, generate files, and execute small coding tasks without you watching. This is a relatively new addition and deserves its own detailed walkthrough (more on that below).
- Private and local modes: Pair it with Ollama or llama.cpp to keep all inference on your machine, even in an offline environment.
The “Just Works” Version of the Setup
Getting started is more straightforward than you might expect. After installing the plugin, you open the Continue sidebar, click the gear icon, and edit a config.json file that lives in your home directory. The onboarding wizard offers several preconfigured presets, including OpenAI, Anthropic, Google, and Ollama. Select one, paste in your API key if needed, and you are ready to type your first prompt.
Take a typical VS Code setup: you choose Ollama as the fast autocomplete source with qwen2.5-coder:1.5b, and then set Claude Sonnet as the chat model. Continue.dev will keep the autocomplete response time low while saving the heavy reasoning for the chat, where latency matters less. The model server runs inside your terminal, but Continue.dev takes care of all the API plumbing.
Agents, Slash Commands, and the Workflows You Define
The longer you use Continue.dev, the more you will find yourself treating it as a framework rather than a fixed product. The real power comes from writing your own prompts and entire agent definitions. For example, you can create a slash command named /refactor-function that accepts a function name, reads the current file, searches the rest of the project for usages, and proposes a refactor that keeps the public API intact.
Crafting these custom helpers is where the community has gone deep. Small teams are sharing their configs in public repositories so others can copy a polished code review prompt or a domain-specific converter. If you have ever wanted an AI assistant that follows your project’s commit conventions or your team’s test naming patterns, you can encode those rules into a reusable prompt. To go further, the project also supports full-blown Continue agents, which are separate processes designed with access to tools, a loop, and a goal. If you are curious about how to build such agents from scratch, this practical guide to building your own Continue.dev agents walks through everything from the initial YAML layout to debugging a suspended agent.
Continue.dev vs Cursor: Picking a Lane
If you have read about Cursor’s impressive capabilities, you might wonder why anyone would choose Continue.dev. Cursor pushes a polished, integrated assistant experience with a sophisticated background agent model and an excellent edit workflow. It also pulls your codebase into its own storage system to power its search and context retrieval.
Continue.dev differs because it chooses to be a plugin, not a platform. It plugs into your existing editor, with all the keybindings and themes you already like, and Cursor’s codebase-aware editor is fundamentally a standalone product. The trade-off is clear: Cursor offers a richer built-in experience but a walled garden, while Continue.dev gives you pieces you can assemble yourself.
In practice, the choice often comes down to how much you value your existing editor configuration and whether you mind paying for another IDE subscription. Many developers maintain both, using Cursor for structured “agentic” tasks and Continue.dev for day-to-day edits in their main IDE. But if you want a tool that does not require you to leave your current setup, Continue.dev removes that barrier.
Privacy, Local Models, and Running Offline
Privacy is another scoring point for Continue.dev. Because the plugin is open-source, you can inspect everything it sends over the network. For developers bound by non-disclosure agreements, that transparency is a lifeline.
You can also use Continue.dev with a fully local backend. Ollama supports modern coding-optimised models like Llama 3.1 8B and Qwen 2.5 Coder that run comfortably on a MacBook Pro with 16 GB of RAM or a PC with an NVIDIA GPU with 6 GB of VRAM. Code autocomplete and chat comments will feel slower than a hosted service, but the contents of your source files never leave your machine. For sensitive client work, this local mode turns what was once a security headache into an acceptable fact.
There are also hybrid setups. A developer might use a local model for suggestions in secure code blocks and a remote model for general queries where speed and insight matter more. Continue.dev lets you define those routing rules in the config file, so you don’t have to switch manually between environments.
Real Workflows That Send Dev Teams Forward
How do people actually use Continue.dev beyond the demo? A few patterns keep resurfacing in community discussions:
First, there is the “explain this legacy codebase” workflow. A new hire opens the project, highlights the module they are about to touch, and asks Continue.dev to walk through the event flow. The assistant pulls in relevant files and produces a short architecture note. This turns a two-day orientation into a two-hour session.
Second, the “generate a test suite” workflow. Instead of manually writing all happy-path tests for a REST API, a developer writes a slash command that asks the model to read a file and produce a complete Pytest or Jest test file in the repository’s style. The model runs test generation, then the developer reviews the output line by line. One team reported that this cut their typical implementation task from 3.5 hours to under 1 hour.
Third, the “structured refactor” workflow. Using inline code edits, developers instruct the model to rename a variable across several files or to change function calling conventions. Since Continue.dev can show a diff before applying anything, the human keeps the final say.
Each of these workflows benefits from being able to tailor both the prompts and the models to the task at hand. That is something prepackaged assistants rarely handle well.
Building a Setup That Grows With You
Continue.dev is not a toy, but it does require a little willingness to tinker on your end. If you would rather not manage multiple API keys or download model weights, a commercial product such as Cursor might be a better fit. If you prefer an assistant that bends to your habits instead of the other way around, Continue.dev rewards the effort with remarkable freedom.
The project evolves quickly, so the exact configuration syntax you use today might be deprecated in a few months. That is the price of being on the cutting edge. But the community is responsive, and the documentation includes examples for common tasks. You can copy those samples and adapt them to your own stack.
Start small: install the extension, wire up one model, and give it a narrow job like writing clearer commit messages. Once you notice how you want it to behave differently, tweak the config. Before long, you will have a personalised coding assistant that is truly yours—and that feels like a breath of fresh air in a market dominated by one-size-fits-all products.