Continue.dev Deep Dive

★ ★ Continue.dev (github.com/continuedev/continue, Apache 2.0) is the dominant FOSS IDE AI assistant — VS Code and JetBrains extensions, multi-provider, with the best self-hosted FIM (fill-in-middle) tab-completion experience in 2026. Where Cline / Roo Code are agentic ("model runs commands"), Continue is assistant-flavoured ("you accept suggestions"). Both have value; pick based on shape of work.

For terminal pair programming see Aider; strategic overview at agentic coding overview; coding model picks at coding models; hardware at tiers.

What Continue is

• ★ Chat panel in VS Code / JetBrains.
• ★ ★ FIM tab completion — the canonical local-Copilot experience. Type code, get a grey completion, Tab to accept.
• ★ Edit mode — highlight code, ask for an edit, get a diff to review.
• ★ Slash commands — /edit, /comment, /test, etc.; user-extensible.
• ★ Custom context providers — pull in @-mention sources (files, codebase, docs, terminal output).
• ★ Local-model first — explicitly designed to make Ollama / LM Studio / vLLM work well.
• ★ MCP support — see MCP servers.
• License: Apache 2.0.

Why people pick Continue over Cline

• Predictability. It doesn't autonomously edit and run things. You stay in control.
• FIM tab completion. Cline doesn't do this; Continue does it well.
• Lighter footprint — less aggressive context use; saner with smaller local models.
• Less risk — no shell command auto-execution.
• JetBrains support — first-class IntelliJ/PyCharm/WebStorm/etc.

Why people pick Cline over Continue

• Agent loops. Continue won't autonomously run terminal commands and iterate; Cline will.
• More aggressive autonomy — when the model is good (Claude Sonnet 4.7), Cline's autonomy is genuinely productive; Continue feels manual by comparison.

Configuration model

Continue's ~/.continue/config.json (and config.yaml in newer versions) declaratively defines:

• Models — chat models, autocomplete models, embedding models.
• Context providers — @codebase, @file, @terminal, @docs, @web, custom.
• Slash commands — built-in and custom.
• MCP servers — tool integrations.

Example (simplified):

{
  "models": [
    { "title": "Qwen Coder 32B", "provider": "ollama", "model": "qwen2.5-coder:32b" },
    { "title": "Claude Sonnet 4.7", "provider": "anthropic", "model": "claude-sonnet-4-7-20250409" }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen Coder 7B",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b-base"
  },
  "embeddingsProvider": { "provider": "ollama", "model": "nomic-embed-text" }
}

FIM tab completion — picks for May 2026

• ★ ★ Qwen2.5-Coder 7B-base — the local FIM default; runs in <100ms on a 3060 12GB.
• ★ Qwen2.5-Coder 1.5B-base — Tier 0 / CPU-friendly; surprisingly OK.
• ★ Qwen2.5-Coder 14B-base — slightly better; bigger latency tax.
• DeepSeek-Coder 6.7B-base — older but strong FIM; memory-efficient.
• StarCoder 2 3B / 7B — fully-open-data alternative.

Use the -base variants for FIM; instruct/chat variants are wrong shape.

Codebase context

@codebase triggers a vector search over your repo. Set up:

• Local embeddings model (e.g., nomic-embed-text).
• Vector index (built automatically; stored in .continue/index/).
• Re-index when significantly changed.

For larger codebases, this is genuinely useful — the model gets relevant context across files without you manually pasting.

Slash commands and customs

Built-in: /edit, /comment, /share, /test, /cmd, /clear, /onboard.

Custom: TypeScript / Python functions; you can write your own.

Honest gotchas

• @codebase quality depends on the embeddings model. Use bge-m3 or nomic-embed-text minimum; small embedding models miss intent.
• Tab completion latency — sub-200ms is the target; a 7B-base on a 3060 12GB hits this; CPU is borderline.
• Context window — bump Ollama's num_ctx to 32K+ for the chat model, which sends a lot of @-mentioned content.
• Two models running simultaneously — autocomplete + chat can saturate VRAM. Tier 2 (24GB) handles 32B chat + 7B autocomplete; Tier 1 (12GB) needs to share or pick one.

Continue.dev vs. Cursor

• Cursor — closed source, paid (~$20/mo Pro); polished; tight UI; hard to beat on the hardest agentic tasks; data goes to providers.
• Continue.dev — FOSS, free, OS-agnostic, multi-provider, local-friendly; less polished UI; predictable.
• Continue.dev + local Qwen2.5-Coder is the FOSS Cursor alternative in 2026. The gap on hardest tasks is real; for routine FIM + chat editing, Continue is excellent.

Pick this if…

• You want OSS Cursor alternative: ★ ★ Continue.dev.
• You want tab completion locally: ★ ★ Continue.dev with Qwen2.5-Coder 7B-base.
• You want chat in IDE, no autonomy: Continue.dev.
• You want autonomous agent in IDE: Cline.
• You're a JetBrains user: Continue.dev (or Cursor, but it's VS Code only).
• Self-hosted Copilot, FIM-only, no chat: TabbyML.