What Is Continue?
Continue is an open-source AI code assistant extension for Visual Studio Code and JetBrains IDEs that connects your development environment to any large language model (LLM). Developed under the Apache 2.0 licence by Continue Dev, Inc., the project acts as a modular control plane for inline code generation, chat, and automated refactoring using either local engines (like Ollama or vLLM) or commercial APIs (such as Anthropic, OpenAI, and Mistral).
- Repository: continuedev/continue
- Primary Interfaces: VS Code Extension Marketplace, JetBrains Plugins Repository
- Supported Backends: Ollama, vLLM, LM Studio, Anthropic, OpenAI, Together AI, AWS Bedrock
The Walled Garden Dilemma in Modern Code Assistants
Most proprietary coding tools treat developers like tenants in a serviced flat: you get a lovely countertop, but you are not allowed to touch the wiring, and someone from head office is quietly auditing your water usage. Closed ecosystems like GitHub Copilot or bespoke AI-first forks lock you into their choice of model, their telemetry policies, and their monthly subscription billing. If your enterprise policy forbids shipping proprietary source code to a third-party server, or if you simply fancy testing the latest open-weights coder without migrating editors, you hit a brick wall.
The tech community across YouTube and developer subreddits has increasingly rallied around modularity. Developers want the seamless autocomplete and diff-based edits of modern coding extensions, but with the liberty to route sensitive internal repositories through an on-premise model running on an RTX 4090, while offloading tricky architectural queries to a frontier cloud model.
This is precisely where Continue fits. It decouples the user interface from the underlying intelligence.
┌────────────────────────────────────────────────────────┐
│ IDE Layer (VS Code / JetBrains) │
│ Inline Autocomplete │ Sidecar Chat │ Actions │
└───────────────────────────┬────────────────────────────┘
│ (config.yaml / json)
▼
┌────────────────────────────────────────────────────────┐
│ Continue Engine │
│ Context Providers (@codebase, @docs, @diff) │
└─────────────────────┬──────────────────┬───────────────┘
│ │
Local Engine ▼ ▼ Cloud Engine
[Ollama / vLLM] [Anthropic / OpenAI]
(Zero Data Leak) (Deep Reasoning)
Key Architecture and Capabilities
Continue does not merely paste responses into an iframe. It constructs a deep semantic pipeline directly within your editor:
1. Pluggable Model Routing: You can specify distinct models for separate tasks. Use a nimble, quantised model for latency-sensitive tab-autocomplete, a mid-sized local model for inline editing, and a flagship frontier model for conversational codebase exploration.
2. Dynamic Context Providers (@ indexing): By typing @ in the chat panel, you can instantly pull relevant context into your prompt. The @codebase provider uses local embeddings via LanceDB to retrieve semantically relevant snippets without indexing files to remote services. You can also inject @terminal, @git-diff, or custom @docs URLs directly into your prompt.
3. Custom Slash Commands: Automate repetitive chore work. Commands like /test or /edit can be wired to bespoke prompt templates stored in version-controlled config files within your team's repo.
4. Local Data Sovereignty: Running Continue with a local backend means zero bytes of source code or telemetry leave your machine, satisfying compliance audits without sacrificing modern developer ergonomics.
Feature Comparison: Continue vs Proprietary Rivals
| Feature | Continue (continuedev/continue) | GitHub Copilot | Proprietary AI Forks (e.g., Cursor) |
|---|---|---|---|
| Licence | Open Source (Apache 2.0) | Proprietary | Proprietary |
| Model Freedom | Any (Local, Self-Hosted, Cloud APIs) | Vendor-curated list | Curated Cloud Models |
| Local Offline Execution | Native support via Ollama / LM Studio | No | No |
| Editor Support | VS Code, JetBrains (IntelliJ, PyCharm, etc.) | Broad IDE ecosystem | Hard-forked VS Code only |
| Context Indexing | Local vector store (LanceDB) | Remote indexing | Remote / Custom indexing |
| Configuration Format | Local YAML / JSON in repository or home | GUI / Subscription portal | GUI / Account settings |
Quick-Start Setup Guide
Getting Continue running with a local model takes less than five minutes. Here is how to configure Continue using Ollama for entirely private, offline coding.
Step 1: Install the Extension
Search for Continue in the VS Code Marketplace or the JetBrains Plugin Marketplace and click Install.
Step 2: Set Up Your Local Model
Install Ollama and pull an efficient code model:
# Pull an optimised code-completion model
ollama pull qwen2.5-coder:7b
# Pull a fast model dedicated to tab autocomplete
ollama pull starcoder2:3b
Step 3: Configure config.yaml
Continue uses a clear configuration file located at ~/.continue/config.yaml. Open your settings and define your models:
name: Local Dev Stack
version: 0.1.0
models:
- name: Qwen 2.5 Coder 7B
provider: ollama
model: qwen2.5-coder:7b
roles:
- chat
- edit
tabAutocompleteModel:
name: StarCoder2 3B
provider: ollama
model: starcoder2:3b
customCommands:
- name: test
prompt: "Write complete unit tests for the selected code using standard British naming where applicable, covering common edge cases."
description: "Generate unit tests"
context:
- provider: codebase
- provider: diff
- provider: terminal
Once saved, the Continue sidebar instantly reflects your custom setup. You can highlight any snippet, hit Ctrl+I (or Cmd+I), and request targeted changes directly in your editor canvas.
Practical Code Walkthrough: Contextual Refactoring
Imagine you have inherited a fragile Python script handling API calls. By combining Continue's inline editor with local context, you can prompt:
/edit Refactor this function to implement exponential backoff and replace print statements with structured logging.
Continue generates a side-by-side git-style diff:
# Before Refactor
import time
import requests
def fetch_payload(url):
for i in range(3):
try:
return requests.get(url).json()
except Exception as e:
print(f"Error: {e}")
time.sleep(1)
return None
# After Refactor (Generated by Continue)
import logging
import time
import requests
from typing import Optional, Dict, Any
logger = logging.getLogger(__name__)
def fetch_payload(url: str, max_retries: int = 3, base_delay: float = 1.0) -> Optional[Dict[str, Any]]:
for attempt in range(max_retries):
try:
response = requests.get(url, timeout=5.0)
response.raise_for_status()
return response.json()
except requests.RequestException as err:
delay = base_delay * (2 ** attempt)
logger.warning("Request failed: %s. Retrying in %.1fs (Attempt %d/%d)", err, delay, attempt + 1, max_retries)
time.sleep(delay)
logger.error("Failed to retrieve payload from %s after %d attempts", url, max_retries)
return None
You can accept or reject individual hunks with a single keystroke (Ctrl+Shift+Enter or Cmd+Shift+Enter), retaining complete control over what makes it into your commit.
Why Continue Matters for Developers
Continue is not simply an alternative interface; it is an insurance policy against platform lock-in. When a new open-weights model drops, you do not need to wait for a service provider to approve, monetise, and roll it out. You update one line in your configuration file, spin up an endpoint, and start building immediately.