Continue – Create Custom AI Code Assistants

TL;DR

TL;DR: Continue is an open-source VS Code and JetBrains extension that lets developers build, share, and use custom AI code assistants built from any LLM, MCP server, and assistant rules.

Source and Accuracy Notes

• Official site: continue.dev
• GitHub: continuedev/continue (33,497 stars)
• Continue Hub: hub.continue.dev/explore/assistants
• This article covers the Continue Hub launch (YC S23) and the open-source extensions.

What Is Continue?

Continue is an open-source extension for VS Code and JetBrains that enables developers to create, share, and use custom AI code assistants. Rather than being locked into a single provider’s opinionated assistant, Continue’s open architecture lets you wire together any combination of:

• Large language models (Claude, GPT-4, Gemini, local models via Ollama)
• MCP servers for tool use (file system, Git, database, Slack, etc.)
• Assistant rules that define behavior, tone, and workflow

The result is a custom AI coding assistant tailored to your stack, your codebase conventions, and your team’s workflows — not a generic assistant that doesn’t know your internals.

Continue launched on YC (Summer 2023) and has since accumulated over 33,000 GitHub stars. The recent launch of Continue Hub adds a registry for sharing and discovering these custom assistants.

Setting Up Continue

Step 1: Install the Extension

Install from the VS Code Marketplace or JetBrains Plugin Repository:

# VS Code — search "Continue" in Extensions panel
# Or install via command line
code --install-extension continue.continue

For JetBrains (IntelliJ, PyCharm, WebStorm, etc.), search “Continue” in the JetBrains Marketplace.

Step 2: Connect Your LLM Provider

On first launch, Continue prompts you to configure a provider. The setup UI walks you through:

• API key entry for OpenAI, Anthropic, Google, or other providers
• Self-hosted option for Ollama, LM Studio, or any OpenAI-compatible API
• Model selection per project

You can configure multiple providers and switch between them per assistant definition.

Step 3: Add MCP Servers (Optional)

MCP servers extend Continue’s capabilities with structured tools. Add them via Continue → Config → MCP Servers:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/workspace"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "."]
    }
  }
}

The MCP registry at modelcontextprotocol.github.io lists hundreds of community servers.

Step 4: Explore Continue Hub

Visit hub.continue.dev/explore/assistants to browse pre-built assistants. These are configuration files that define a specific LLM, set of rules, and MCP servers for a particular use case.

Example assistants available on the Hub:

• Data load tool (dlt) specialist — uses the dlt MCP server for data pipeline tasks
• Legacy code modifier — applies specific patterns for updating old codebases
• Pull request reviewer — connects to GitHub for context-aware PR reviews

Click “Use” on any assistant to import it into your local config.

How the Hub Works

Continue Hub is a registry for building blocks and composed assistants:

| Component | What it does | |---|---| | Models | LLM configurations (provider, model ID, API base) | | Rules | System prompts and behavioral guidelines | | MCP Servers | Tool definitions and their configurations | | Assistants | A named combination of models + rules + MCP servers |

You can compose an assistant entirely through the Hub UI without touching config files. For example, choose Claude as the model, add a “code review” rule, and wire in the GitHub MCP server — you get a Claude-powered PR reviewer with no config file editing.

Building blocks are individually shareable: if you define a great set of assistant rules for your team’s codebase, others can import just that rule and pair it with their own model choice.

Under the Hood

Continue’s architecture has three layers:

┌─────────────────────────────────────────────┐
│           Continue Hub (Registry)           │
│  Share and discover building blocks        │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│          Config (.continue/)                 │
│  assistants.ts — compose assistants         │
│  rules.ts — define behavioral rules         │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│       Continue Extensions (VS Code/JB)       │
│  Chat interface, editor integration,        │
│  LLM provider abstraction, MCP client        │
└─────────────────────────────────────────────┘

The config lives in .continue/assistant.ts in your project root — it’s a TypeScript file you can version-control alongside your codebase, making assistant configurations portable.

Use Cases

1. Project-specific assistants

Create an assistant that knows your codebase’s patterns, naming conventions, and architecture. This avoids the generic “I don’t know your project” problem that plagues general-purpose AI assistants.

2. Team-shared coding standards

Define rules that enforce your team’s style guide, PR requirements, or architecture decisions. Import the config in .continue/ and the entire team gets the same assistant behavior.

3. MCP-powered tool use

Connect to MCP servers for structured tool access — query databases, interact with GitHub, call internal APIs — and expose those tools to your AI assistant with full schema awareness.

4. Multi-model comparison

Configure the same rules and MCP servers across multiple models (Claude, GPT-4, Gemini) and compare outputs directly in the chat panel.

Practical Evaluation Checklist

• [ ] Extension installs without conflicts on VS Code latest
• [ ] API key configuration saves and persists across restarts
• [ ] Chat context includes current file and selection
• [ ] MCP servers connect and tools are recognized
• [ ] Continue Hub assistant import works end-to-end
• [ ] Multi-model switching is seamless
• [ ] Config file (assistant.ts) is version-control friendly
• [ ] JetBrains version parity with VS Code extension

Security Notes

• API keys are stored in the extension’s local storage or your system’s credential manager — not sent to any third party
• The config file (.continue/) may contain sensitive MCP server credentials — add it to .gitignore if your MCP servers require authentication tokens
• Continue does not anonymize or aggregate your code — queries go directly to your chosen LLM provider under their respective privacy terms
• For enterprise use, self-hosting an LLM (via Ollama or LM Studio) keeps all code local

FAQ

Q: Does Continue work offline?

A: Yes — if you configure a self-hosted model via Ollama or LM Studio on localhost, Continue works entirely offline. The extension still functions; only the Hub discovery feature requires an internet connection.

Q: What’s the difference between Continue and GitHub Copilot?

A: Copilot is a fixed, Microsoft-curated assistant. Continue is an open framework for composing your own assistant from any LLM and MCP server. Where Copilot gives you what Microsoft thinks you need, Continue lets you define exactly what your assistant knows and can do.

Q: Can I use Continue with local models?

A: Yes. Configure any OpenAI-compatible API endpoint (Ollama, LM Studio, llama.cpp server, etc.) in the provider settings. Set the API base to http://localhost:11434 for Ollama defaults.

Q: Does Continue work with JetBrains?

A: Yes. The JetBrains extension is available in the JetBrains Marketplace and supports the same feature set as the VS Code version.

Q: How does the Hub differ from just editing the config file manually?

A: The Hub provides a UI for composing assistants without touching TypeScript. You can also share and discover building blocks (rules, MCP configs) that others have published. The underlying config is still a .continue/assistant.ts file that you own and control.

Conclusion

Continue solves the “one assistant doesn’t fit all” problem by making AI code assistants composable and open. With 33K GitHub stars and an active ecosystem of MCP servers, it’s the closest thing to a standard framework for building project-specific AI coding tools.

If you spend significant time in VS Code or JetBrains and find general-purpose AI assistants frustratingly generic, Continue is worth trying — you can have a project-aware assistant configured in five minutes, and the Hub gives you a library of pre-built compositions to start from.

Get started: continue.dev → install the extension → configure your first model → explore the Hub.