Windsurf + Ertas

Overview

Windsurf, developed by Codeium, is an AI-native code editor designed from the ground up to integrate large language models into every aspect of the development workflow. Unlike editors that bolt AI onto existing interfaces, Windsurf treats AI assistance as a first-class citizen — offering intelligent autocomplete, multi-file editing, codebase-aware chat, and automated refactoring tools that understand project context. Its Cascade feature can reason across entire repositories, making it particularly effective for complex codebases.

Despite its advanced context-gathering capabilities, Windsurf's underlying models are trained on general programming data. They excel at common patterns and popular frameworks but lack knowledge of your organization's proprietary libraries, internal APIs, and team-specific conventions. When working with custom frameworks or domain-specific abstractions, suggestions may miss the mark — defaulting to generic implementations instead of leveraging your team's carefully crafted utilities and architectural patterns.

How Ertas Integrates

Ertas bridges the gap between Windsurf's powerful editor features and your team's unique codebase knowledge. By collecting examples of your best code — approved PRs, internal documentation, architectural decision records, and style guides — you build a training dataset that encodes your organization's coding standards. Ertas Studio manages the fine-tuning process, allowing you to train a model that understands your naming conventions, preferred design patterns, and internal API surface without requiring ML infrastructure expertise.

After fine-tuning, you deploy the model through an OpenAI-compatible endpoint using Ollama or a similar local runtime. Windsurf supports custom model endpoints, allowing your fine-tuned model to power its autocomplete, chat, and Cascade features. The result is Windsurf's sophisticated multi-file reasoning combined with a model that genuinely understands your project — suggesting code that uses your actual utilities, follows your team's patterns, and respects your architectural boundaries, all while keeping your code entirely on your own infrastructure.

Getting Started

1. 1

   Curate your codebase training data

   Extract representative code samples from your repository: well-reviewed pull requests, internal library implementations, documentation comments, and configuration patterns. Format them as instruction-response pairs that demonstrate your coding conventions.

2. 2

   Train a custom model with Ertas Studio

   Upload your dataset to Ertas Studio and select a code-capable base model. Configure LoRA-based fine-tuning parameters and start the training job. Use Ertas's experiment tracking to compare different configurations and select the best-performing checkpoint.

3. 3

   Deploy the model with a local inference server

   Export the fine-tuned model in GGUF format and deploy it through Ollama, exposing an OpenAI-compatible API endpoint. Test the model with representative coding prompts to verify it captures your team's patterns accurately.

4. 4

   Connect Windsurf to your custom model endpoint

   Configure Windsurf's model settings to point to your local inference endpoint. Map the model to Windsurf's autocomplete and chat features so your fine-tuned model powers the AI assistance throughout the editor.

5. 5

   Iterate and improve model quality

   Monitor the model's suggestions during real development work. Collect corrections and edge cases where the model deviates from your standards, add them to the training dataset, and run incremental fine-tuning to tighten alignment over time.

Benefits

• Windsurf's multi-file reasoning powered by a model that understands your specific codebase
• Autocomplete suggestions that use your internal libraries and follow your naming conventions
• Complete data sovereignty — training data and inference stay on your infrastructure
• No recurring per-seat AI costs for your team once the model is deployed locally
• Cascade feature enhanced with knowledge of your project's architecture and dependencies
• Continuous refinement loop as your codebase evolves and new patterns emerge