How to Configure Continue.dev: A Step-by-Step Setup With Real Prompts

Most people install Continue.dev, watch a chat panel appear in the sidebar, ask it to write a Fibonacci function, then quietly stop using it. The interesting part of the tool isn’t the panel. It’s the config file, the context system, and the fact that you can run a frontier model for chat while a 7B model handles tab completion on your laptop without an internet connection.

What follows is the setup I run daily on a TypeScript and Python monorepo, written out from a clean install. Budget about 20 minutes.

Step 1: Install it and pick two models

Grab the Continue extension from the VS Code marketplace (publisher: Continue Dev, Inc.). The JetBrains plugin reads the identical config file, so everything below carries over with different keyboard shortcuts.

Continue ships with no model of its own. You bring an API key for Anthropic, OpenAI, Gemini or Mistral, or you point it at Ollama running locally. That open architecture is the main reason people switch to it, and it’s covered in more depth in this look at the open-source coding assistant that lets you pick its brain.

Use one model for typing, another for thinking

Autocomplete fires every time your fingers pause. Chat fires a few times an hour. Treat them as different products with different budgets.

• Tab completion: Codestral, or Qwen2.5-Coder 7B through Ollama. Sub-300ms latency matters far more here than raw intelligence.
• Chat and inline edits: Claude Sonnet or a GPT-4-class model, where you’re paying per call rather than per keystroke.

If you’d rather test the waters before connecting a card, this rundown of what free AI chat tiers actually give you in 2025 is a sensible five-minute read before you start pasting keys into a config file.

Step 2: Write a config that fits a real project

Click the gear icon in the Continue sidebar, or create ~/.continue/config.yaml yourself. Older tutorials show config.json and even config.py; current builds read the YAML file.

models:
  - title: Claude Sonnet
    provider: anthropic
    model: claude-sonnet-4-20250514
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
  - title: Qwen2.5 Coder
    provider: ollama
    model: qwen2.5-coder:7b

tabAutocompleteModel:
  title: Codestral
  provider: mistral
  model: codestral-latest
  apiKey: ${{ secrets.MISTRAL_API_KEY }}

contextProviders:
  - name: file
  - name: folder
  - name: diff
  - name: terminal
  - name: codebase

allowAnonymousTelemetry: false

Three parts of that file do the heavy lifting. tabAutocompleteModel sits outside the models list, which is exactly what makes the two-model split possible. contextProviders decides what you can pull into a prompt with an @ mention. And allowAnonymousTelemetry: false keeps outbound pings switched off if your employer has opinions about that.

Reload the window after every edit. One bad indent makes Continue fall back to defaults without a visible error message, and that is the most confusing five minutes in this whole process.

Step 3: Learn the three ways it touches your code

Mixing these up is the fastest route to hating the tool.

Inline edit, Cmd or Ctrl + I

Select a block, hit the shortcut, describe the change. Keep instructions bounded: “swap requests for httpx, add a 5 second timeout, raise RetryError instead of returning None.” Continue rewrites just the selection and shows you a diff to accept or reject. It’s for transformations with clear edges, not vague requests like “make this better”.

Chat panel

For questions that span files. Why a migration runs twice in staging. How the billing service decides to retry. What that mystery cron job does at 3am.

Tab autocomplete

Type a function signature, pause half a second, accept with Tab. There’s nothing to learn beyond building the habit.

Step 4: Give chat real context

A model with no context will invent your database schema with total confidence. The @ mentions are how you stop that.

• @file attaches a specific file, whether or not it’s open in a tab.
• @folder pulls in a whole directory tree.
• @codebase runs semantic search across everything you’ve indexed.
• @terminal pipes in your last terminal output, the fastest route to understanding a stack trace.
• @diff attaches uncommitted changes, which turns “review what I just wrote” into a single line.

One prompt that earns its keep: @diff @file payments/retry.py The loop doubles the delay on a 429 but not on a 503. Is that deliberate? Show me the backoff timeline for five attempts. You get a table, a direct answer, and a very specific question to take to whoever wrote it two years ago.

Step 5: Add slash commands and a rules file

Continue ships with /edit, /comment, /test, /explain and /commit. That last one writes a commit message from your staged diff and justifies the install on its own.

Custom commands are markdown files in .continue/prompts/. Here’s a review.prompt that pays for itself within a week:

---
name: review
description: Check staged changes against team rules
---
Read @diff and flag bare except clauses, network calls with no
timeout, leftover print statements, and functions over 50 lines.
Group findings by file. Do not rewrite the code.

A .continuerules file at the repo root does the same job for every prompt rather than one. Write your style rules there once and stop repeating yourself in chat.

Step 6: Index the codebase

Run “Continue: Index Codebase” from the command palette. A 200,000-line repository takes a few minutes. The extension chunks your files and embeds them so @codebase can locate the right snippet instead of grepping blindly.

Check .continueignore before you start. If node_modules, dist and generated protobuf files aren’t listed, you’ll spend an afternoon watching a progress bar. Re-index after large refactors too, otherwise chat will confidently reference files that were deleted months ago.

Step 7: Where this leaves Copilot and Cursor

Continue’s pitch is that you own the model and the prompts. Copilot’s is that it works out of the box inside GitHub, and Copilot’s current pricing and where it still falls short is a fair comparison point if you’re already paying for a subscription. Cursor takes a third route, rebuilding the editor around a codebase-aware AI editor rather than extending the one you already have.

Plenty of teams end up running Continue alongside one of the others. It costs nothing to install, and the whole configuration is one file you can delete in ten seconds if it doesn’t stick.

Gotchas that eat your first hour

• Autocomplete feels sluggish. Your autocomplete model is too large. Drop to a 7B local model or Codestral.
• Chat ignores the file you’re staring at. Attach it with @file. Don’t assume the editor buffer is included automatically.
• Config edits appear to do nothing. Nearly always YAML indentation. The Continue output channel shows the real parse error.
• Keys that worked yesterday now return 401. You stored them in an environment variable that VS Code, launched from a desktop icon, never inherited. Export it in your shell profile instead.
• Indexing never finishes. Missing or incomplete .continueignore.

Fix the autocomplete model first. It’s the single change that turns Continue from something you open deliberately into something that quietly helps while you type.