The Building Blocks of an AI Coding Assistant

In my latest newsletter, I ranted about how most developers approach AI coding assistants wrong.

We're treating these tools like magic boxes instead of understanding their components. Today, I’ll dive into what makes a coding assistant work, using continue.dev—an open-source platform changing our view on AI coding tools. I'll break down the seven essential building blocks.

As I shared in my newsletter, my Go programming journey was transformed by leveraging these building blocks. When I started with Go, I struggled with its idioms and best practices. But by creating a customized coding assistant that indexes official documentation and enforces idiomatic patterns, I’ve dramatically accelerated my learning. What used to take hours now happens seamlessly.

I’m focusing on the Continue coding assistant because it’s the first I’ve used with this paradigm.

Breaking Down the AI Coding Assistant

If you've followed my work, you know I'm passionate about demystifying dev tools. The problem with most AI coding approaches is developers expect too much ("AI do my job") or too little ("it's just fancy autocomplete"). The reality lies in between, and understanding the building blocks helps us use these tools effectively.

Models

Models specify Large Language Models (LLMs) and other deep learning models for roles in the open-source IDE extension like Chat, Autocomplete, Edit, Embed, Rerank, etc. Explore available models on the hub.

Continue supports many model providers like Anthropic, OpenAI, Gemini, Ollama, Amazon Bedrock, Azure, xAI, DeepSeek, and more. Models can have roles such as chat, edit, apply, autocomplete, embed, and rerank. Read more about roles here. View models in the YAML Reference for details.

The key advantage is running your assistant locally with Ollama. Check out Chad's article on leveraging Ollama and Gemma 3.

Context​

Context blocks define a provider referenced in Chat with @ to pull data from external sources like files, URLs, Jira, Confluence, and GitHub issues. Explore context provider blocks on the hub.

context:
  - id: go-docs
    name: Go Documentation
    description: Official Go programming language documentation
    sources:
      - type: web
        url: https://golang.org/doc/
      - type: web
        url: https://golang.org/doc/effective_go

  - id: go-stdlib
    name: Go Standard Library
    description: Go standard library documentation
    sources:
      - type: web
        url: https://pkg.go.dev/std

With this setup, reference Go documentation in chats using @go-docs or access the standard library with @go-stdlib. This has greatly boosted my productivity when writing Go code, as mentioned in my AI coding newsletter.

Learn about context providers here this guide here and create your own with. Find the config.yaml spec for context.

Docs​

Docs are blocks pointing to documentation sites, indexed locally for reference using @Docs in Chat. Explore docs on the hub.

See my docs example in the rules section.

MCP Servers

Model Context Protocol (MCP) servers are popular, and Continue has had this as a primitive for some time. MCP is a standard for building and sharing language model tools, defined in mcpServers blocks. Explore MCP Servers on the hub.

MCP is the new AI buzzword, with many usage examples.

Rules​

Rules blocks are instructions your custom AI code assistant always considers. The contents are inserted into the system message for all Chat requests. Explore rules on the hub.
rules:
  - id: effective-go
    name: Effective Go Guidelines
    description: Rules for writing idiomatic Go code
    content: |
      When writing or reviewing Go code, adhere to these Effective Go principles:
      1. Use proper error handling with explicit error returns
      2. Prefer composition over inheritance
      3. Follow Go naming conventions (CamelCase for exported, camelCase for internal)
      4. Use interfaces for abstraction and testing
      5. Use the standard library effectively
      6. Implement proper concurrency patterns with goroutines and channels
      7. Write clear and concise comments for exported functions

I've complemented this by indexing the official Effective Go documentation.

docs:
  - name: Effective Go
    version: 0.0.1
    schema: v1
    startUrl: https://go.dev/doc/effective_go

This setup ensures my coding assistant follows Go best practices and can reference official guidelines. As I mention in my newsletter, domain-specific rules enhance AI-generated code relevance.

Learn more in the rules deep dive, and see in the YAML Reference for details.

Prompts

Prompts blocks are reusable prompts for chat, useful for repetitive or complex tasks. Explore prompts on the hub.

prompts:
  - id: go-hype-beast
    name: Go Hype Beast
    description: A prompt for idiomatic Go code assistance
    prompt: |
      You are a Golang programming assistant. Help developers write clean, idiomatic, efficient Go code by following these best practices:

      1. Use gofmt for consistent formatting.
      2. Follow Go naming conventions:
         • CamelCase for exported names, camelCase for unexported.
         • Avoid stuttering in package names (e.g., vectordb.New() not vectordb.NewVectorDB()).
         • Name interfaces as "doers" (e.g., Reader, Writer).
      3. Write clear, concise code:
         • Keep functions small and focused.
         • Use meaningful names.
         • Limit line length, but don't obsess.
      4. Handle errors explicitly:
         • Check and handle errors immediately.
         • Avoid panic.
      5. Use Go's concurrency features:
         • Goroutines for concurrency.
         • Channels for communication.
      6. Optimize for readability and maintainability:
         • Explain "why" in comments.
         • Use defer for cleanup.
      7. Leverage Go's type system:
         • Use structs for related data.
         • Implement interfaces implicitly.
      8. Follow idiomatic Go patterns:
         • Prefer composition over inheritance.
         • Use slices over arrays when possible.
      9. Optimize performance:
         • Use efficient data structures and algorithms.
         • Profile and benchmark when necessary.
      10. Ensure code safety and security:
          • Use go vet and golint.
          • Avoid global variables when possible.

      When providing code examples, adhere to these principles and explain your recommendations. For style decisions, refer to the Go Style Guide and Effective Go documentation.

The "Go Hype Beast" prompt ensures my coding assistant provides idiomatic Go code suggestions following best practices. It transforms the assistant into a specialized Go expert, understanding the language philosophy. Combined with Effective Go documentation, it creates a powerful Go development environment.

Prompt blocks share the same syntax as prompt files but differ in two key ways:

1. Prompt blocks can't use context providers.
2. They're stored in config.yaml, not .continue/prompts.

Find the config.yaml spec for prompts here.

Data​

Data blocks send development data to chosen destinations, useful for analysis, insights, or model fine-tuning. Learn more about development data here and explore data block examples here.

Configure data destinations in the data section of config.yaml.

Why This Matters

The block-based approach isn't just technical; it fundamentally shifts how we view AI coding assistants. Instead of a mysterious code generator, it offers a transparent, customizable toolset.

This modular approach allows you to:

1. Customize your assistant for specific languages or frameworks.
2. Swap components as better models emerge.
3. Understand how the assistant makes suggestions.
4. Build trust through transparency.

The Future is Composable

I'm thrilled by continue.dev's alignment with the Unix philosophy: tools should excel at one task and integrate via simple interfaces. By breaking down the assistant into seven blocks—Models, Context, Docs, MCP Servers, Rules, Prompts, and Data—continue.dev enables specialized assistants for diverse tasks.

Want a Python refactoring whiz? Combine retrieval blocks that understand Python idioms with transformation blocks for refactoring. Need documentation help? Mix generation blocks with retrieval blocks tailored to your team's style guide.

Build Your Own Assistant

The power of continue.dev is that it puts you in control. Instead of relying on commercial assistants, you can create the perfect assistant by combining these seven building blocks. Understanding them is crucial for an AI coding assistant that truly boosts your workflow.

If you prefer not to start from scratch, remix mine from my Continue profile:

https://hub.continue.dev/bdougie