Continue: Open-Source AI Coding Assistant for VS Code and JetBrains

AIContinueVS CodeGitHub

Continue (~35k stars) is an open-source AI code assistant for VS Code and JetBrains. Bring your own models, customize autocomplete and chat, wire custom context providers, and keep more control than a closed Copilot-only stack. Where Cline ships a polished autonomous agent loop out of the box, Continue leans modular: you assemble chat, tab completion, and agent modes from config — ideal for teams with security reviews, unusual endpoints, or multi-IDE standards.

Why Continue matters

GitHub Copilot set expectations — inline ghosts, chat, maybe agents — but not every company can send code to a single US-hosted model. Continue became the default open answer for:

  • Bring-your-own-model (OpenAI, Anthropic, Ollama, Together, Azure OpenAI, etc.)
  • JetBrains parity alongside VS Code — one config story for Android, IntelliJ, and WebStorm shops
  • Config as code — config.yaml in repo or user profile, shareable via Git
  • Custom context — @-mention docs, folders, Git diff, issue trackers via providers
  • Local/offline paths when paired with local inference

Installation

VS Code: Install “Continue” from the Marketplace. On first launch it guides you to add a model provider.

JetBrains: Install the Continue plugin from the JetBrains marketplace for your IDE version.

Then create or sync configuration:

YAML
# ~/.continue/config.yaml (illustrative — see docs for current schema)
models:
  - title: Claude Sonnet
    provider: anthropic
    model: claude-sonnet-4-20250514
    apiKey: <YOUR_KEY>
tabAutocompleteModel:
  title: Qwen2.5 Coder
  provider: ollama
  model: qwen2.5-coder:7b

Pin Continue versions per team — plugin + CLI mismatches cause confusing errors after upgrades.

Core workflows

Inline chat on selection: Highlight a function, ask for a refactor, apply diff — the bread-and-butter pair programming loop.

Tab autocomplete: Point tabAutocompleteModel at a fast local model for latency-sensitive completion; use a larger model only for chat.

Agent mode (when enabled in your version): Multi-step edits with tool calls — closer to Cline, but still orchestrated through Continue’s config and permission model.

Shared team config: Commit a trimmed continue_config.json or documented template to the repo so interns and contractors inherit the same models and banned paths.

Continue vs Cline vs Copilot

GitHub Copilot is zero-config and deeply integrated if your org already pays — but you inherit Microsoft’s model routing and data policy. Cline optimizes for “agent with terminal and browser” inside VS Code with minimal YAML surgery. Continue optimizes for your stack: mixed IDEs, local models, custom docs indexes, and gradual rollout (autocomplete first, agents later).

For terminal-first multi-file git commits without an IDE plugin, add Aider. For a Cursor-like editor experience with built-in AI, evaluate Void — different tradeoff (fork maintenance vs plugin).

Local models and air-gapped setups

Continue + Ollama (or vLLM on an internal GPU box) is a common pattern for regulated environments. Expect to tune smaller models — they autocomplete fine but struggle with multi-file agents. Many teams run local autocomplete only and allow cloud chat for complex questions, splitting risk.

Bash
ollama pull qwen2.5-coder:7b
# Point Continue tabAutocompleteModel at localhost:11434

Best practices

  • Start with chat + autocomplete before enabling aggressive agent tools
  • Add rules inspired by awesome-cursorrules — stack, test command, dependency policy
  • Scope context providers — dumping the whole monorepo wastes tokens (context guide)
  • Verify packages before install (hallucinated packages)
  • Document API key storage — OS keychain vs CI secrets vs shared .env never committed

WordPress and JetBrains

PHPStorm + Continue is a natural fit for WordPress agencies living in JetBrains. Point context at theme app/ or plugin src/, keep Composer and PHPCS commands in rules, and use Continue for refactors — not for bulk editing ACF field values. For spreadsheet content ops, standardize on Quickfields Bulk Editor for ACF in wp-admin.

Risks

  • Config drift between teammates on different Continue versions
  • Over-broad @-context leaking unrelated proprietary files into prompts
  • False confidence from fluent chat on code the model never executed

FAQ

Is Continue free? The extension is open source; you still pay for cloud APIs or infra for local GPUs.

Does it support agents? Continue has been expanding agent capabilities — check the docs for your pinned release; feature names shift.

Can I use one config in VS Code and IntelliJ? Aim for shared model definitions; exact file paths differ slightly per host.

Continue vs Continue Dev (CLI)? Watch the monorepo — the project ships multiple entrypoints; follow README for the IDE plugin vs headless tools.

Deep dive: context providers

Continue’s superpower is assembling context deliberately. Use @Files, @Folder, @Git, and custom providers instead of hoping the model guesses. In a monorepo, create a team doc listing which folders to @-mention for each service — prevents shipping the wrong package.json. For docs-heavy stacks, index internal Markdown with a provider rather than pasting fifty pages into chat.

Enterprise deployment pattern

Regulated teams often deploy Continue with: Azure OpenAI or private VPC endpoints, JetBrains for backend/Java shops and VS Code for web, shared config.yaml in an internal Git repo, and autocomplete pointed at a local code model while chat uses the approved cloud model. Security reviews like Continue because prompts can stay inside contractual boundaries — unlike opaque SaaS copilots where routing changes silently.

Troubleshooting common failures

  • Autocomplete silent — tab model endpoint down or wrong port for Ollama
  • Chat works, agent does not — check permissions and Continue version pin
  • JetBrains lag — reduce context provider scope; large @Folder kills latency
  • YAML schema errors — validate against current docs after upgrades

Repo

github.com/continuedev/continue