What Continue actually is

Continue is an open source AI coding assistant that lives inside your editor. Unlike closed source tools, the codebase is on GitHub and the configuration is a plain JSON file you control. At a technical level it does three things: it sends your code context plus your prompt to an LLM provider you choose, it renders the response back into the editor as chat, inline edits, or autocomplete suggestions, and it manages the context window so the model sees the right files.

The interesting part is the provider layer. Continue does not lock you into one model. You point it at OpenAI, Anthropic, Mistral, a local Ollama server, or any OpenAI compatible endpoint. You can swap models per tab. A typical setup uses a strong model for chat and a faster cheaper model for autocomplete.

It runs as a VSCode extension and a JetBrains plugin. The extension handles the editor integration. A small Python or Node service called the Continue CLI handles background indexing of your repo so the assistant can pull in relevant files automatically. You do not need to think about the CLI much, it starts when the extension starts.

Setup and authentication

The fastest path is the VSCode marketplace. Open VSCode, hit the extensions panel, search Continue, install the one published by Continue.dev. After install you get a new icon in the activity bar and a chat panel on the left.

On first launch Continue asks you to pick a provider. The simplest choice is Anthropic or OpenAI. You paste an API key and Continue stores it in your operating system keychain, not in plain config. If you would rather not send code to a third party, pick Ollama as the provider, install Ollama locally, pull a model like qwen2.5-coder or deepseek-coder, and Continue talks to it over localhost.

Authentication looks like this for Anthropic. Open the config.json file. Continue exposes it through the gear icon in the chat panel, or you can open it directly at the path shown in the docs for your OS. Add a models entry in plain JSON with provider set to anthropic, apiBase pointing at the Anthropic endpoint, and apiKey read from environment. The cleanest pattern is to set ANTHROPIC_API_KEY in your shell profile and reference it from config as env variable substitution. That way the key never lives in the file.

For local models the config is similar but provider is ollama and apiBase is http://localhost:11434/v1. You do not need an apiKey. Continue treats Ollama as an OpenAI compatible endpoint.

Once the config is saved, reload the VSCode window. The status bar should show the model name. If it shows a connection error, the most common cause is a stale API key or a firewall blocking the provider URL.

First working example

Open a small project, anything with a handful of source files. A Python script with a couple of helper modules works well. Highlight a function, press Cmd+L on Mac or Ctrl+L on Windows to open the chat panel with the selection as context. Type “explain what this function does and suggest two edge cases it does not handle”.

Continue sends the file path, the selected code, and your prompt to the configured model. Within a few seconds you get a response in the chat panel. You can click any code block it returns and hit Apply, which writes the diff back into your file at the cursor.

For inline edits the workflow is different. Highlight code, press Cmd+I to open the inline edit box. Type “add input validation for null and empty string”. Continue streams a diff directly into the editor. You accept with Tab or reject with Escape.

Autocomplete works passively. As you type, Continue suggests completions in faded grey. Tab to accept, Escape to dismiss. The first completion is often slow because the extension warms up the local context index. After that it feels close to instant for typical file sizes.

A concrete first task that demonstrates the loop well: open a TypeScript file with a function that handles an HTTP request. Ask Continue in chat to “refactor this to use async await and add error handling”. Review the diff it proposes. Apply it. Run the tests. If something breaks, highlight the failing test, paste the error into chat, and ask for a fix. This three step loop of generate, run, debug is the core workflow.

Key settings that matter

The config.json file has more knobs than most people realize. The ones that change behavior the most are tabSize, contextLength, and the slash commands section.

tabSize controls how many lines of context above and below your cursor get sent with each prompt. Default is typically around 8. Bumping it to 16 or 24 helps when you are working in a long function and the model needs to see more of the surrounding logic. The trade-off is token cost per request.

contextLength sets the maximum tokens the model sees. For Claude Sonnet and GPT-4 class models this can go up to the full window. For smaller local models you want to cap it lower, often in the 4 to 8 thousand range, to keep latency acceptable.

The slash commands section is where you define reusable prompts. A common pattern is a /test command that takes the current file and asks the model to write unit tests. Another is /review that asks for a code review focused on a specific concern like security or performance. Defining these once means you stop typing the same prompts over and over.

The system prompt field is also worth touching. Continue ships with a default that is fine for general use. For a specific stack, say a Django codebase, you can add “you are an expert Django developer, prefer class based views, follow PEP 8” and the responses get noticeably more on target.

Context providers are another dial. By default Continue uses the current file plus your selection. You can add providers that pull in @ symbols, file paths, or even grep results from the repo. The docs list the available providers. Adding the codebase provider makes the assistant aware of your whole repo, which costs more tokens but produces much better answers for cross-file questions.

Where it shines

Continue is at its best when you treat it as a pair programmer that knows your codebase. The codebase context provider is the killer feature here. Ask “where is the user authentication handled” and it will grep through the repo, find the relevant files, and summarize. That kind of question is painful to answer with a generic chatbot.

Refactoring is another strong area. Highlight a chunk of code, ask for a refactor toward a specific pattern, and the inline edit flow makes it easy to review and accept. The diff is shown directly in the editor so you can audit every line before applying.

For learning a new codebase, the chat panel is genuinely useful. Paste a file path into chat with the question “walk me through this module”. Continue reads the file and gives you a structured explanation. You can follow up with “what would break if I changed X” and get a sensible answer grounded in the actual code.

Local model support is a quiet win. If you work on proprietary code that cannot leave your machine, Continue plus Ollama plus a capable local coder model gives you a workable assistant with no data leaving your laptop. The quality is lower than the frontier models, but for autocomplete and small edits it is good enough for daily use.

Where it fails

The autocomplete quality varies wildly by model. With a frontier model it is competitive with the best closed source tools. With a small local model the suggestions are often wrong enough that you spend more time rejecting than accepting. There is no magic here, it reflects what the underlying model can do.

Long context tasks are awkward. Even with contextLength cranked up, the assistant sometimes loses track of details from the start of a long file. For really large refactors across hundreds of files, you are better off with a dedicated agentic tool that can plan and execute.

The context index can get stale. If you rename a file or move a function, Continue may still reference the old path until you reload or until the background indexer catches up. This shows up as the assistant confidently suggesting edits to files that no longer exist.

Configuration errors fail silently in some cases. A wrong apiBase or a missing environment variable often produces a generic connection error in the chat panel with no hint about what is actually wrong. You end up reading logs. This is a real friction point for first time users.

The community config hub is a mixed bag. You can browse and import configs other users have shared. Some are excellent. Some are outdated or reference deprecated model names. Treat imports as starting points, not finished setups.

Practical workflow pattern

A setup that holds up in real work looks like this. Pick one strong model for chat, typically the best Anthropic or OpenAI model you can afford per request. Pick one fast cheap model for autocomplete, often a smaller model from the same provider or a local Ollama model. Configure both in config.json under separate model entries and assign them to the chat and autocomplete roles.

Define three or four slash commands that match your actual work. For a backend developer that might be /test, /review, /explain, and /docstring. For a data analyst it might be /sql-optimize, /pandas-refactor, /chart-explain. The point is to encode the prompts you find yourself typing repeatedly.

Set up the codebase context provider and let it index your repo once. After that, prefer chat questions that reference files by @ or by path rather than pasting code manually. The model gets more accurate context and you type less.

Build a habit around the generate, run, debug loop. Use Continue to draft a change. Run your tests or your script. If something breaks, paste the error back into chat and ask for a fix. Treat the assistant as a fast first draft generator and a patient debugger, not as an oracle.

Finally, version your config.json. Put it in a dotfiles repo or check it into a private config repo. When you upgrade Continue or switch machines, you can restore your full setup in seconds. This is the kind of small habit that pays off after the third or fourth time you set up a new laptop.

The practical next step is the free Working With Claude field guide. Thirty-two pages covering the ecosystem, Claude Code, and how to govern a rollout properly. Get your copy.