TL;DR:

  • Continue.dev is a free, MIT-licensed AI coding assistant plugin for VS Code and JetBrains that works with any model — local via Ollama or cloud APIs via Anthropic, OpenAI, and others
  • Code never leaves your machine when using local models, making it the default choice for teams under NDA, working with proprietary systems, or subject to data residency requirements
  • The practical setup that works: fast local model (1.5–7B) for tab autocomplete, smarter local or cloud model for chat and edits
  • It’s not as polished as Cursor, but it’s free, auditable, and model-agnostic

The concern with AI coding assistants is real and frequently under-discussed: every piece of code you type into GitHub Copilot, Cursor, or Windsurf leaves your machine. It goes to a cloud API. It may be used to improve models. For most consumer developers this is an acceptable trade for convenience. For teams building proprietary systems, working under NDAs, or subject to data residency regulations, it often isn’t.

Continue.dev solves this by being fully local by default. The extension runs in your IDE, you configure which model to use, and if that model is running on Ollama on your laptop, nothing leaves your network. The codebase context it indexes for retrieval? Stored locally. The chat history? Local. The extension itself is MIT-licensed and auditable.

How Continue.dev Works

Continue installs as a VS Code extension or JetBrains plugin. Once installed, it adds three main interfaces:

Tab autocomplete — single-line and multi-line completions triggered as you type, similar to Copilot’s ghost text. You configure which model handles this separately from the chat model, because autocomplete needs to be fast (50–200ms response), while chat can tolerate a few seconds.

Chat sidebar — a panel where you can ask questions about your codebase, paste error messages, request explanations, or discuss approaches. The chat has access to the current file, highlighted selections, and indexed codebase context.

Edit mode — highlight a block of code, describe what you want changed, and Continue applies the diff. This is the “agentic” capability for targeted changes without touching everything around them.

The key insight for getting the most out of Continue is using different models for different capabilities:

{
  "models": [
    {
      "title": "Qwen 2.5 Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "contextLength": 32768
    },
    {
      "title": "Claude claude-sonnet-4-6 (complex tasks)",
      "provider": "anthropic",
      "model": "claude-sonnet-4-6",
      "apiKey": "$ANTHROPIC_API_KEY"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:1.5b",
    "contextLength": 4096
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text"
  }
}

This configuration uses Qwen 2.5 Coder 1.5B for autocomplete — it’s fast enough to complete inline without interrupting flow — and Qwen 32B for chat on complex tasks. For requests that genuinely need stronger reasoning, switching to Claude via API in the sidebar costs fractions of a cent per query and is still within your control about what gets sent.

Teams that want fully local operation on commodity hardware should look at Qwen 2.5 Coder 7B for both chat and autocomplete — it’s a good balance of quality and speed on a machine with 16GB RAM.

Codebase Context and Retrieval

One of Continue’s strengths is its codebase indexing. When you enable @codebase in the chat, Continue embeds your repository using the configured embeddings model and stores the index locally. You can then ask questions like “where is the payment processing logic handled?” or “find all places we validate email addresses” and Continue retrieves relevant files.

This is materially more useful than pasting individual files into context. It works particularly well for onboarding — new contributors can ask questions about architecture and get answers grounded in actual code rather than potentially stale documentation.

The index updates incrementally as you edit files. For large repositories (100k+ files), the initial indexing takes 5–15 minutes depending on the embeddings model speed.

How It Compares to Copilot and Cursor

GitHub Copilot: Copilot is simpler to set up, has excellent autocomplete trained on vast public code, and integrates more deeply into GitHub workflows (PR review, Copilot Workspace). It does not support local models and code is sent to GitHub’s servers. For most open-source work, that’s fine. For proprietary code, it requires careful review of Microsoft’s data handling terms.

Cursor: Cursor has the most polished UX of any AI code editor currently available — Composer mode for multi-file changes, excellent codebase search, and a thoughtful diff review interface. It is a closed-source fork of VS Code and code is sent to Cursor’s servers unless you configure API keys directly. Cursor’s recent tier changes have also made the free tier less useful for heavy users.

Continue: Worse UX polish than either, but free, open source, and completely private with local models. The JetBrains support is genuinely good — important for Java, Kotlin, and Python teams on IntelliJ or PyCharm. The model flexibility is unmatched: you can swap between any provider without vendor lock-in.

Who Should Use Continue.dev

Continue is the right choice for teams that need to keep code off third-party servers — legal teams with privileged communications, financial services with customer data in codebases, defence contractors, and companies where source code exposure is a material IP risk. It’s also the practical choice for developers who want to experiment with local models without paying for cloud APIs on every query.

For solo developers without privacy requirements who want the best possible coding assistance experience, Cursor or a Copilot subscription will deliver better results for the same or lower cost. Continue’s advantage is the privacy guarantee and model flexibility, not maximum capability per query.