Continue.dev is an open-source AI coding assistant that runs entirely in your editor, giving you full control over models, context, and data privacy. Unlike closed-source alternatives, Continue.dev lets full-stack developers wire up everything from local Ollama models to enterprise GPT-4 endpoints without leaving VS Code or JetBrains.
I've spent the last six months using Continue.dev across production TypeScript, Python, and even some Go services. Here's what actually matters, what breaks, and how to make it earn its place in your daily workflow.
Why Continue.dev Matters (and When to Skip It)
The pitch is simple: AI assistance without the cloud dependency. You get autocomplete, chat, and code generation directly in your IDE, with every prompt and response flowing through configurable providers. For teams under compliance pressure or developers working on air-gapped systems, that's not a nice-to-have — it's the difference between having AI and not having it.
But here's the honest take: if you're happy with Copilot or Cursor and don't care about model choice or data residency, Continue.dev adds setup overhead you might not need. It's a tool for developers who want to own their AI stack, not rent it. If that's not you, skip it.
Getting Started with Continue.dev
Install the extension from the VS Code marketplace or JetBrains plugin repository. Then create a config.json in ~/.continue/ — this is your entire control plane. Here's a minimal working setup using OpenAI's API:
{
"models": [
{
"title": "GPT-4o",
"provider": "openai",
"model": "gpt-4o",
"apiKey": "YOUR_API_KEY"
}
],
"embeddingsProvider": {
"provider": "openai",
"model": "text-embedding-3-small"
}
}
That's it. Restart your editor, highlight some code, and hit Cmd+L to open the chat. For a local setup with Ollama:
{
"models": [
{
"title": "Llama 3.1 8B",
"provider": "ollama",
"model": "llama3.1:8b"
}
]
}
Core Continue.dev Concepts Every Developer Should Know
1. Context Providers
Context providers feed your prompt with relevant code, files, or docs. Without them, the model works blind. The @codebase provider is the workhorse — it embeds your entire repo and retrieves relevant chunks automatically.
// In config.json, enable the codebase provider for chat
"contextProviders": [
{
"name": "codebase",
"params": {
"include": ["src/**/*.ts", "src/**/*.tsx"],
"exclude": ["node_modules", "dist"]
}
}
]
2. Custom Slash Commands
Slash commands are reusable prompt templates. Instead of typing the same request every time, define a command that injects your project's coding standards into every prompt.
{
"commands": [
{
"name": "review",
"description": "Get a code review focused on security",
"prompt": "Review the following code for security vulnerabilities, focusing on injection attacks, auth bypasses, and unsafe deserialization. Suggest fixes in TypeScript.\n\n{{input}}"
}
]
}
3. Model Roles
You can assign different models to different tasks. Use a fast local model for autocomplete and a powerful cloud model for complex refactoring. This keeps latency low and costs even lower.
{
"autocomplete": {
"provider": "ollama",
"model": "codellama:7b"
},
"models": [
{
"title": "GPT-4o",
"provider": "openai",
"model": "gpt-4o"
}
]
}
4. Fine-Tuned Embeddings
The @codebase provider works better when embeddings match your codebase's language and style. Train a custom embedding model on your private code if you're dealing with a large monorepo. It's a one-time cost that pays off in retrieval accuracy.
Common Continue.dev Mistakes and How to Fix Them
Mistake 1: Not Configuring Context Providers
Most developers install Continue.dev, open chat, and ask questions without setting up @codebase. The model then answers from its training data — which is useless for your private codebase. Fix: always prefix prompts with @codebase or configure it as the default context provider.
Mistake 2: Using One Model for Everything
I see developers run autocomplete, chat, and embeddings all through GPT-4. That's expensive and slow. Fix: use a small local model for autocomplete (7B params is plenty), a mid-tier cloud model for chat, and a vector-specific embedding model. Your response times will drop from seconds to milliseconds.
Mistake 3: Ignoring the Rules File
Continue.dev supports a rules file that injects project-specific instructions into every prompt. Skipping this means the AI doesn't know your naming conventions, error handling patterns, or framework versions. Fix: create ~/.continue/rules.txt with your team's coding standards, then watch the output quality jump.
When Should You Use Continue.dev?
Use Continue.dev when you need data privacy, model flexibility, or cost control that closed-source assistants can't provide. It's the right choice for teams working with proprietary codebases, regulated industries like healthcare or finance, or developers who want to experiment with different models without switching editors.
Skip it if you're a solo developer who values zero-config convenience over control. Copilot and Cursor are excellent products — Continue.dev is for those who want to build their own AI workflow. If you're already comfortable with Docker and API keys, the learning curve is trivial.
Continue.dev in Production
Tip 1: Version-Control Your Config
Your config.json and rules file should live in your repository. Teams drift apart when every developer configures their own AI stack. Define one canonical config, commit it, and let everyone pull from the same source of truth.
Tip 2: Set Hard Rate Limits
When you're running production workloads through an API, costs spiral fast. Configure rate limits and token caps in your provider settings. I've seen teams burn thousands of dollars in a week because they left unlimited access on.
Tip 3: Log and Audit Prompts
If you're using Continue.dev in a regulated environment, enable prompt logging. It's a checkbox in the config, and it gives you a complete audit trail of what the AI saw and generated. This saves you during compliance reviews and helps debug weird model behavior.
The single most valuable thing you can do this week is create a rules.txt file that captures your team's coding standards, then wire up a local model for autocomplete. That one hour of setup will change how you write code forever.