Extending VS Code with Continue to Leverage ChatGPT

Understanding Continue as an AI Code Agent

Continue represents a new category of developer tools that bridge the gap between traditional IDE extensions and standalone AI assistants. Unlike simple code completion tools or chat interfaces, Continue functions as a comprehensive AI code agent capable of understanding your entire codebase, executing multi-step tasks, and integrating seamlessly with your existing development processes. The extension has garnered over 1.9 million installations on the VS Code marketplace, reflecting its widespread adoption and community trust.

Four Core Capabilities

The platform's architecture revolves around four core capabilities that address different aspects of the development workflow:

Agent mode enables AI to perform complex multi-step tasks, read and write code, and execute commands on your behalf. Chat mode provides an interactive conversational interface where you can ask questions about your codebase, request explanations, or brainstorm solutions. Edit mode allows you to describe changes you want to make and have the AI apply them directly to your files. Autocomplete mode offers intelligent inline suggestions as you type, similar to GitHub Copilot but with the flexibility to use any supported AI model.

Open-Source and Model-Agnostic

What distinguishes Continue from proprietary alternatives is its open-source nature and model-agnostic approach. Rather than locking you into a single AI provider, Continue supports integration with multiple models including OpenAI's GPT-4, Anthropic's Claude, open-source models through services like Ollama, and custom endpoints. This flexibility means you can choose the model that best balances capability, cost, and privacy requirements for each task. For organizations concerned about data security, Continue can be configured to use local models that never send code to external servers. Our guide on authorizing AI agents provides additional insights on implementing secure AI controls in your development workflow.

ChatGPT Integration Configuration

To leverage ChatGPT through Continue, you need to configure an API connection to OpenAI's services. This requires an OpenAI API key, which you can obtain through your OpenAI account at platform.openai.com. Navigate to your account settings, create a new API key, and store it securely. Never commit API keys to version control or share them publicly.

With your API key ready, open Continue's configuration file by clicking the gear icon in the Continue sidebar or running the "Continue: Open Config" command from the command palette. The configuration file uses JSON format and includes a section for model configuration.

Continue supports multiple concurrent model configurations, allowing you to switch between models depending on task complexity and cost considerations. For routine coding tasks, GPT-3.5-Turbo provides excellent results at a fraction of GPT-4's cost, while more complex reasoning tasks benefit from GPT-4's advanced capabilities. Understanding the trade-offs between different AI models is essential for building cost-effective solutions--our OpenAI vs Open Source LLM guide provides comprehensive guidance on selecting the right model for your needs.

Agent Mode for Complex Tasks

Agent mode represents Continue's most powerful capability, enabling the AI to execute multi-step tasks that span multiple files and require understanding of code relationships. When you initiate an agent task, the AI analyzes your request, creates a plan, and iteratively works through each step while keeping you informed of progress.

Consider a scenario where you need to add internationalization support to an existing application. Rather than manually updating every string literal across dozens of files, you can instruct the Continue agent to "Add i18n support using react-i18next, extract all hardcoded strings to translation files, and add the necessary configuration." The agent will then examine your codebase, identify strings needing translation, create the appropriate translation files, and modify your code to use the translation system.

The agent achieves this through a combination of code reading, generation, and editing capabilities. It can create new files, modify existing ones, and even run shell commands when necessary. Throughout the process, you maintain oversight and can intervene at any point to guide the agent's direction or approve specific changes. This human-in-the-loop approach ensures that AI assistance enhances rather than replaces developer judgment. Building AI agents that work effectively with human oversight is a core competency of our web development services, where we integrate intelligent automation into production applications.

Chat Mode for Exploration and Learning

Chat mode provides a conversational interface for interacting with your codebase and the AI model. Unlike traditional search or documentation tools, the chat interface understands natural language queries and can provide contextually relevant responses based on your specific codebase.

Common use cases for chat mode include understanding unfamiliar code, debugging issues, and exploring architecture decisions. When you inherit a legacy codebase, you might ask "How does the authentication system work?" and receive an explanation that synthesizes information from authentication-related files, configuration, and dependencies. Similarly, when debugging a complex issue, you can describe the symptoms and ask the AI to help identify potential causes based on code patterns in your project.

The chat interface also supports code examples and explanations. You can paste in a code snippet and ask for clarification on how it works, suggestions for improvement, or comparisons with alternative approaches. This makes chat mode particularly valuable for learning new frameworks or patterns while maintaining productivity on your current tasks.

Edit Mode for Targeted Modifications

Edit mode bridges the gap between chat and agent modes, providing AI-assisted code modifications without the overhead of full task decomposition. When you have a clear idea of what changes you want to make but need help implementing them, edit mode allows you to describe the desired change and have the AI apply it directly to your selected code.

The edit command accepts a natural language description of the change you want to make. For example, selecting a complex function and typing "Simplify this function by extracting the validation logic into a separate helper function" will prompt the AI to analyze the selected code, identify the validation portion, create an appropriately named helper function, and update the original code to call it.

Edit mode works particularly well for refactoring tasks, bug fixes, and adding features to existing code. Because it operates on your current selection, you maintain precise control over which parts of your codebase are modified. The AI considers the surrounding context when generating edits, ensuring that changes integrate smoothly with the rest of your code.

Autocomplete for Real-Time Suggestions

Autocomplete mode provides intelligent inline suggestions as you type, similar to GitHub Copilot but with Continue's model flexibility. As you write code, the extension analyzes your context--including open files, imports, and project structure--to generate relevant completions. These range from simple variable names and method calls to entire function implementations.

The quality of autocomplete suggestions depends heavily on context configuration. When configured properly, autocomplete can significantly accelerate typing by suggesting complete statements, import statements, and boilerplate code. For example, when importing a library, autocomplete might suggest the full import statement based on the partial text you've typed and your project's dependencies.

Unlike edit mode, autocomplete suggestions are ephemeral and disappear if not accepted. This makes it a low-risk way to incorporate AI assistance into your workflow, as you can freely accept or reject suggestions without committing to changes. Over time, you develop intuition for when autocomplete will be helpful, typically for well-understood patterns and frequently used code structures.

Pre-Commit Workflow Integration

Before committing changes, developers often perform quick sanity checks and cleanup tasks. Continue can accelerate this process by generating commit messages that accurately describe your changes, running automated formatting suggestions, and identifying potential issues before they enter the repository. The AI's ability to understand change context makes it particularly effective at writing informative commit messages that help teammates understand the evolution of the codebase.

Similarly, Continue can assist with pull request descriptions by summarizing the changes made and their rationale. This is especially valuable for large PRs where manually documenting every modification becomes tedious. The AI can analyze the diff and generate a comprehensive description that highlights key changes, new functionality, and modified behavior.

Code Review Assistance

During code review, Continue can serve as a first-pass reviewer that identifies common issues before human review. You might use the chat interface to ask "What potential issues might exist in this code?" and receive feedback on areas that warrant closer examination. This doesn't replace thorough human review but helps ensure common issues are caught early.

The edit mode also proves valuable during review, allowing reviewers to quickly propose fixes for minor issues they identify. Rather than leaving comments asking for specific changes, reviewers can create the proposed edits directly, reducing back-and-forth communication and accelerating the review cycle.

Documentation Generation

Maintaining documentation often falls behind code changes, but Continue can help by generating initial documentation from code analysis. When adding a new function or class, you can use the chat to request documentation comments that describe the function's purpose, parameters, return values, and usage examples. While AI-generated documentation should always be reviewed for accuracy, it provides a valuable starting point that reduces documentation friction.

For larger documentation efforts, such as API documentation or architectural overviews, Continue can synthesize information from across your codebase to create comprehensive documents. This is particularly useful for onboarding new team members or creating external documentation for API consumers.

Model Selection by Task Complexity

Different tasks have different complexity requirements, and matching task complexity to model capability can significantly reduce costs without sacrificing quality. Simple tasks like generating boilerplate code or explaining straightforward code patterns work well with cheaper models like GPT-3.5-Turbo, while complex tasks involving multi-step reasoning or nuanced understanding benefit from GPT-4.

Consider establishing team conventions for model selection. Define criteria for when to use each available model, and train team members on these conventions. For example, you might establish that edit suggestions should use the faster model, while architectural questions warrant the more capable model. These conventions become particularly important as team usage scales.

Context Management

Every piece of context sent to the AI model contributes to token usage and cost. Optimizing context means sending only the information necessary for the current task. For simple edits, limit context to the specific function or file being modified rather than sending the entire codebase. For chat questions, clearly define the scope of what you want to know rather than asking broad questions that require extensive context processing.

Continue's configuration includes options for controlling default context behavior. Review these settings to ensure they align with your cost management goals. You might configure the extension to require explicit context selection rather than automatically including all open files, making developers more conscious of what information they're providing.

Response Management

The length and detail of AI responses directly impacts token usage. Encourage team members to provide specific, focused prompts that elicit concise responses rather than broad requests that trigger verbose explanations. Phrasing matters significantly--asking "What does this function do?" typically produces shorter responses than "Please explain this function in detail, including its purpose, parameters, return values, and any side effects."

For tasks that require longer responses, consider breaking them into smaller steps. Rather than asking for a comprehensive refactoring plan all at once, request a high-level overview first, then drill into specific areas. This approach not only reduces costs but often produces better results by keeping each AI interaction focused and manageable.