Continue

What it is and who it's for

Continue is an open-source AI code assistant that integrates directly into your VS Code or JetBrains IDE. Unlike many proprietary AI tools, Continue distinguishes itself by allowing developers to use virtually any Large Language Model (LLM) for their coding tasks, whether it's a cloud-based service like OpenAI's GPT-4, Anthropic's Claude, or a locally run model via Ollama or LM Studio. It provides a chat interface within your IDE, enabling you to ask questions, generate code, refactor functions, debug issues, and write tests, all while maintaining awareness of your current project context. Continue is designed for developers who value flexibility, privacy, and control over their AI tooling. It's particularly useful for those who want to experiment with different LLMs, keep sensitive code off cloud servers by using local models, or customize their AI workflows beyond what off-the-shelf solutions offer.

Key Features

• LLM Agnostic: Connect to any LLM. This includes popular cloud APIs like OpenAI (GPT-3.5, GPT-4), Anthropic (Claude), Google (Gemini), and many others. Crucially, it also supports local models through services like Ollama, LM Studio, and LocalAI, allowing for offline use and enhanced privacy.
• Context Awareness: Continue automatically sends relevant context from your project to the LLM, such as open files, selected code, and recent changes. This eliminates the need to copy-paste code into a separate chat window, ensuring the AI has the necessary information to provide accurate suggestions.
• Inline Code Editing and Generation: Beyond chat, Continue allows you to select code and apply AI transformations directly. You can use commands like /edit to modify selected code, /fix to debug, or /test to generate unit tests, with the changes appearing as diffs for easy review and acceptance.
• Custom Commands and Workflows: Developers can define their own custom commands and multi-step workflows using a simple configuration. This enables automation of repetitive tasks, creation of specialized prompts, or chaining multiple AI actions together to achieve complex outcomes specific to a project or team.
• VS Code and JetBrains Integration: Available as an extension for both VS Code and JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, etc.), providing a native and familiar user experience within your development environment.
• Chat History and Session Management: All your interactions with the AI are saved within the IDE, allowing you to revisit previous conversations, copy responses, or continue a discussion from where you left off across different coding sessions.
• Open-Source and Extensible: Being open-source, Continue benefits from community contributions and allows developers to inspect, modify, and extend its functionality to suit their specific needs, fostering transparency and adaptability.

Getting Started

Setting up Continue is straightforward, though configuring local models requires a few extra steps.

Installation

For VS Code:

1. Open VS Code.
2. Go to the Extensions view (Ctrl+Shift+X or Cmd+Shift+X).
3. Search for "Continue" and select the one published by "Continue Dev".
4. Click "Install".

For JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, etc.):

1. Open your JetBrains IDE.
2. Go to Settings/Preferences (Ctrl+Alt+S or Cmd+,).
3. Navigate to Plugins.
4. Search for "Continue" in the Marketplace tab.
5. Click "Install" and then restart your IDE when prompted.

Configuration

After installation, a Continue sidebar will appear in your IDE. The first time you open it, Continue will guide you through selecting an LLM. You can also manually configure models via the config.json file.

Example: Configuring OpenAI (Cloud LLM)

1. Obtain an OpenAI API key from platform.openai.com.
2. In VS Code, open the Continue sidebar, then click the gear icon (Settings) or press Ctrl+Shift+P / Cmd+Shift+P and search for "Continue: Edit Config".
3. Add or modify the models array in your ~/.continue/config.json (or the project-specific .continue/config.json) as follows:

{
  "models": [
    {
      "name": "gpt-4-turbo",
      "provider": "openai",
      "apiKey": "YOUR_OPENAI_API_KEY",
      "model": "gpt-4-turbo-preview"
    },
    {
      "name": "gpt-3.5-turbo",
      "provider": "openai",
      "apiKey": "YOUR_OPENAI_API_KEY",
      "model": "gpt-3.5-turbo"
    }
  ]
}

Replace "YOUR_OPENAI_API_KEY" with your actual key. It's recommended to set API keys as environment variables for security (e.g., OPENAI_API_KEY=sk-...) and reference them in the config: "apiKey": "{{ env.OPENAI_API_KEY }}".

Example: Configuring Ollama (Local LLM)

1. Download and install Ollama from ollama.com/download.
2. Run a model locally using Ollama. For example, to run Code Llama:

   ollama run codellama

   This will download and start the codellama model.
3. Add the Ollama provider to your config.json:

{
  "models": [
    {
      "name": "codellama",
      "provider": "ollama",
      "model": "codellama"
    }
  ]
}

Ensure the "model" name matches the model you pulled with Ollama.

Basic Usage

1. Open the Continue sidebar in your IDE.
2. Select your desired LLM from the dropdown at the top of the chat panel.
3. Type your request in the chat input. For example: "Write a Python function to reverse a string."
4. To apply AI suggestions to your code:
   • Chat: Ask questions or generate code. The AI will respond in the chat panel.
   • Inline Edit: Select a block of code in your editor. Then, in the Continue chat panel, type a command like /edit Refactor this function to be more concise. or /fix Find and fix any bugs in this selection. Continue will show a diff, which you can accept or reject.
   • Generate: Place your cursor where you want to generate code and type your prompt in the chat.

Pricing

Continue itself is completely free and open-source. There are no subscription fees, paid tiers, or premium features locked behind a paywall for the Continue extension. The "cost" associated with using Continue comes from the Large Language Models (LLMs) you choose to integrate:

• Cloud-based LLMs (e.g., OpenAI, Anthropic, Google): You pay for the API usage directly to the respective providers based on their token pricing. For example, OpenAI charges per token for input and output, with different rates for models like GPT-3.5 Turbo and GPT-4 Turbo. These costs can vary significantly depending on your usage volume.
• Local LLMs (e.g., via Ollama, LM Studio): Using local models incurs no direct monetary cost per token. However, it requires sufficient local hardware (CPU, RAM, and especially GPU for better performance) and consumes electricity. The "cost" here is primarily in hardware investment and power consumption.

In summary, Continue provides the framework for free, giving you the freedom to choose your preferred LLM and manage its associated costs independently.

Pros

• Unparalleled LLM Flexibility: The ability to choose any LLM, from cutting-edge cloud models to privacy-focused local models, is Continue's strongest advantage. This allows developers to tailor their AI assistant to specific project needs, budget constraints, or privacy requirements.
• Enhanced Privacy and Security: By supporting local LLMs, Continue enables developers to keep sensitive code entirely off cloud servers. This is crucial for projects with strict data governance or proprietary information.
• Deep Customization and Control: Developers can define custom prompts, create complex multi-step workflows, and fine-tune how Continue interacts with their code. This level of control is rare in AI coding assistants and allows for highly specialized use cases.
• Open-Source Transparency: The open-source nature means the community can inspect the code, contribute improvements, and ensure there are no hidden data collection practices. This fosters trust and allows for community-driven development.
• Context-Aware Interaction: Continue's ability to automatically provide relevant project context to the LLM significantly improves the quality and relevance of AI-generated suggestions, reducing the need for manual copy-pasting and prompt engineering.

Cons

• Initial Setup Complexity for Local Models: While cloud LLM setup is simple, configuring local models (e.g., installing Ollama, downloading models, ensuring hardware compatibility) can be more involved and may require some technical troubleshooting.
• Performance Reliance on LLM and Hardware: The speed and quality of responses are heavily dependent on the chosen LLM and, for local models, the user's hardware. Running large models locally without a powerful GPU can lead to slow response times.
• Learning Curve for Advanced Features: While basic chat is intuitive, mastering custom commands, defining complex workflows, and optimizing config.json for specific use cases requires some time and effort to learn the system.
• UI/UX Can Be Less Polished: As an open-source project, the user interface and overall user experience, while functional, might not always feel as polished or streamlined as highly funded commercial alternatives.

Best Use Cases

• Code Refactoring and Optimization: Select a function or class and use commands like /edit Refactor this for better readability and performance. Continue can suggest improvements, simplify logic, or modernize syntax.
• Rapid Prototyping and Boilerplate Generation: Quickly generate initial code for new features, components, or entire files. For example, "Write a React component for a user profile card with props for name, email, and avatar URL."
• Debugging and Error Resolution: Paste an error message or select a problematic code block and ask Continue to /fix it or explain the potential causes and solutions. This can significantly speed up debugging efforts.
• Learning New APIs or Languages: When working with an unfamiliar library or language, ask Continue for examples, explanations of functions, or how to implement specific patterns. For instance, "Show me how to make an HTTP GET request using Python's requests library."

How it Compares

• GitHub Copilot: Copilot offers seamless auto-completion and code generation directly within the editor. It's highly integrated and easy to use, but it's a proprietary, cloud-only service tied to OpenAI's models (and Microsoft's infrastructure). Continue offers far greater flexibility in LLM choice and deep customization, prioritizing user control over out-of-the-box simplicity. Copilot is a subscription service, while Continue is free (excluding LLM API costs).
• Cursor: Cursor is an entire IDE built around AI, offering a more deeply integrated AI experience than an extension. It provides features like "Ask AI" in a new tab, auto-error fixing, and smart diffs. While powerful, Cursor is a more opinionated environment. Continue maintains the familiarity of your existing VS Code or JetBrains setup while adding AI capabilities, and again, offers superior LLM flexibility and open-source transparency.
• Codeium / Tabnine: These tools primarily focus on AI-powered code completion, similar to advanced IntelliSense, suggesting lines or blocks of code as you type. They are excellent for boosting coding speed. Continue, while also offering some completion capabilities through its chat interface, is more geared towards larger-scale code generation, refactoring, debugging, and complex multi-turn interactions, acting more as a full coding assistant rather than just a smart auto-completer.

Verdict

Continue stands out as an exceptional choice for developers who prioritize flexibility, privacy, and deep customization in their AI coding assistant. Its open-source nature and LLM agnosticism provide unparalleled control, making it ideal for those who want to use local models or experiment with various cloud providers. While it might require a bit more initial setup and configuration than some commercial alternatives, the benefits of tailoring your AI experience to your exact needs are substantial, making it a highly recommended tool for the discerning developer.