Most AI coding assistants decide which model produces your answer and keep that choice hidden behind a subscription page. Continue.dev does the opposite. It is an open-source AI assistant for VS Code and JetBrains that lets you plug in any model you can reach, from a small local LLM running in Ollama to a commercial API with your own key.
The first time you open Continue, the interface can feel unremarkable. There is a sidebar panel, a chat input, and an unobtrusive tab-autocomplete system. The real difference is underneath: every request can be routed to a different brain, and every rule for how the assistant behaves sits in config files you can open. When developers start asking where their code goes every time they press Tab, that sort of control becomes valuable.
What Continue.dev actually includes
Continue is more than a chat window attached to your editor. It gives you several ways to work with code:
- Sidebar chat with context from selected code, individual files, your git diff, or a whole-project search using @Codebase.
- Tab autocomplete that picks up on local symbols, imports, and patterns as you type.
- Inline edits, where you highlight a block, describe the change in plain language, and review a diff before accepting it.
- Slash commands and context providers that make common team prompts reusable.
Context is what makes the tool feel more useful than another browser tab. If you are lost in an unfamiliar repository, ask a question and mention @Codebase to search across files. If you are preparing a pull request, select the changed lines and tell the model to focus on failure cases instead of style nits. Because Continue is open source, community contributions have expanded it with integrations for databases, issue trackers, and internal documentation. The core loop stays simple: a prompt goes to the model you chose, and the response arrives where you can act on it.
Why choosing your own model matters
GitHub Copilot offers a polished, settled backend. That setup works well for many people, but it leaves little room for flexibility. Continue.dev treats models as interchangeable building blocks, which matters more than you might expect.
In the extension configuration, you can define separate models for different jobs. A small, low-latency model can handle tab autocomplete because it needs to be quick and cheap. A larger model can handle long chat conversations. A self-hosted model can answer questions about proprietary code without sending a single snippet to an outside vendor. All three can live in the same setup and Continue routes each request to the right one.
The freedom shows up on your first afternoon with the tool. A developer who prefers Anthropic’s style of explanation can use an Anthropic model. A team that standardized on Llama served from an internal OpenAI-compatible endpoint can keep its own stack. You do not have to adapt your workflow to a fixed provider.
How Continue compares with Copilot and Cursor
Copilot’s autocomplete is refined, and many programmers will stay with it for that reason. Continue offers a different trade: it can feel close to Copilot when you pair it with a commercial model, but it puts the policy decisions in your hands. If you work in an environment where code cannot leave the building, Continue connected to a local model can be the only sane way to get AI assistance without a regulatory headache.
Cursor deserves a mention too. Cursor is a full editor built around AI. Continue takes the opposite route by installing directly into your current editor, so it avoids forcing you to migrate to a new tool. It will not feel as deeply woven into every UI surface as Cursor, but it preserves your key bindings, themes, plugins, and muscle memory. For many developers, that tradeoff is worth it.
Getting started: local model or cloud API
The quickest way to try Continue is to install the extension from the VS Code marketplace or JetBrains plugin marketplace, then open the assistant panel. The built-in setup asks which provider you want to use.
For a purely local test, install Ollama and pull a small coding model such as llama3.2 or qwen2.5-coder:7b. Refresh the provider list inside Continue and select Ollama. No API key, no per-seat fee, and no off-machine data. A 7B or 8B model is enough to explain code and generate boilerplate; a larger model helps with harder reasoning if you have the RAM and GPU for it.
If you prefer a commercial model, choose your provider and paste in an API key. Continue supports OpenAI-compatible endpoints, which covers most major providers, plus native integrations for Anthropic, Google Gemini, Mistral, AWS Bedrock, and others. The setup path is short, and the output appears in the editor where the code is, not in a disconnected chat window.
Daily workflows that make Continue useful
Once you have Continue running, it earns its place through small repeated tasks. The exact quality depends on the model behind the prompt, but a clear workflow matters just as much.
Workflows worth trying
- Untangle inherited code. Select a folder or use @Codebase and ask Continue to outline entry points, side effects, and areas that look risky.
- Write unhappy-path tests. Ask for pytest cases that cover boundary conditions, missing data, and timeout behavior rather than just happy paths.
- Review a diff. Create a custom slash command that checks for security issues or silent failure handling and returns concise comments.
- Automate repetitive edits. Highlight several similar blocks and ask the assistant to reformat them according to a rule you describe in one sentence.
Where it still slips
Continue is not a replacement for a careful code review. If the context is incomplete, the model will answer with confidence and no indication that it misread the request. Always give it exact file paths, commands, and constraints. You will also notice that autocomplete is not always as fast as Copilot’s because local models and remote APIs add latency. The strength is not raw speed; it is the ability to switch to a model that behaves the way you want.
Privacy and cost: why teams keep using Continue.dev
For organizations with compliance requirements, local inference changes the conversation. Some code is too sensitive to send to an external provider. Continue works with local models served by Ollama, llama.cpp, vLLM, or a GPU cluster on your own network. That means the code can stay behind your firewall while developers still get autocomplete, explanation, and editing help.
The cost picture is simpler too. There is no monthly per-seat fee for the extension itself. You pay for model tokens or for the hardware running the model. A team of fifty people might replace a per-seat commercial plan with one shared inference box, or they might keep a mix of local models for sensitive files and commercial APIs for everyday tasks. The choice belongs to the user, which is exactly how an open-source assistant should work.
Your configuration file is the real assistant
The first Continue session should not end with a single chat answer. It should end with you opening the configuration file and looking at what controls the behavior. Continue stores its settings in a file that lists the models, custom commands, context providers, and default options. If you ignore that file, you are only seeing a slice of the tool.
Treat the config like source code. Give each provider a clear name, set a low temperature for autocomplete, and add a few slash commands your team uses every day. Later, when you want a model that writes shorter chat replies or one that never references code outside the current repo, you can adjust a few lines instead of relearning a different editor. That is the practical promise of Continue.dev: you do not have to accept a black-box assistant. You can shape it, swap its model, and keep it aligned with how you work. Start with one experiment. Install the extension, select a local model, and ask it to explain a function you wrote six months ago. Then look at the config file and change something. That small act of control is what makes Continue stand out.