Windsurf: Building an AI IDE Around Developer Intent

The developer already has an editor

A Java team may depend on its debugger as much as its editor. Varun describes Codeium customers where more than 70% of developers used JetBrains, with Java debugging a strong reason to stay. Changing source control creates another burden: dependent workflows must move too. An AI assistant entering these companies has to work with tools developers already rely on.

That explains why Codeium began with extensions across integrated development environments, or IDEs. Its enterprise customers used GitLab, Bitbucket, Gerrit, Perforce, and older source-control systems. Broad compatibility gave Codeium access to those developers, but host editors constrained the experience it could build. Windsurf grew from that tension: an editor of its own could bring codebase retrieval, code execution, and AI-assisted iteration together more closely.

In the December 2024 Latent Space conversation, Varun grounds that design in how software takes shape. Generating an initial application from a task description can be useful. Ongoing development, however, clarifies the problem through coding: engineers test approaches, discard ideas, and refine their intent. Windsurf aims to participate in that process without requiring developers to attach every relevant piece of code manually.

Intent lives in the sequence of actions

Anshul identifies three ingredients for the editor: - Knowledge retrieval to gather the information a task needs. - Tool access, including terminal execution. - Developer trajectory: the sequence of navigation, edits, and commands that helps reveal intent. A developer opens a directory, changes some code, and tries a terminal command. Together, those actions can communicate a goal that was never fully written into a prompt.

The extension constraints were concrete. Supercomplete could already suggest refactors, but Varun says VS Code lacked an API to display them as intended. Codeium worked around this by dynamically generating PNGs containing the suggestions. He also reports repeated breakage in APIs used for refactoring. Controlling the editor would let the team improve the interaction directly, especially the essential step of making generated code easy to review.

Cascade is Windsurf’s agentic component: it uses the history of human and AI actions to propose changes and execute code toward a completed work product. The goal is to require less explicit specification while keeping the resulting changes inspectable.

Evaluate the unfinished change

Codeium evaluates this combination of inference and execution using historical code changes: 1. Find open-source commits with associated tests. 2. Remove portions of the changes, leaving incomplete code. 3. Withhold the commit message. 4. Ask the system to retrieve context, infer the intended change, and iterate until the tests pass. This makes software work a masked prediction problem: recover both the missing implementation and the high-level intent behind it.

Withholding the message matters because developers rarely supply a complete specification. Context remains in their heads, conversations, Slack, and issue trackers. Across many repositories, individual pass/fail outcomes become an aggregate signal for improving planning, retrieval, and multistep execution. The team reports progress toward useful first passes in large existing codebases, though it gives no numerical results.

Retrieval gets a separate test. A change often depends on knowledge scattered across a repository, so finding one relevant snippet is insufficient. Codeium describes evaluating roughly 50 retrieved items for coverage of the necessary pieces. Files edited together in old commits provide reference sets, including relationships that may be absent from a code graph. These component tests make retrieval easier to improve; end-to-end tests check whether those improvements help complete the work.

The benchmark discussion distinguishes better scores from better assistance. One speaker argues that SWE-bench and similar tests poorly represent professional work. Another defends benchmarks while using qualitative product experience to find their blind spots. Repeated prompts to run pytest illustrate the concern: an optimization may help a particular test without transferring to broader tasks. As a benchmark approaches saturation, the speakers favor finding a more useful evaluation target over chasing its remaining points.

Autonomy needs a way back

The proposed route to autonomous coding starts inside the IDE. If an agent needs repeated correction even while observing the developer’s activity, that task is a poor candidate for unattended execution. Recurring workflows that succeed without intervention are stronger candidates. The aim is to expand autonomy where work stops requiring repair, while retaining the ability to ask a human for help.

Command execution exposes the immediate tradeoff. Approving every command creates friction; executing arbitrary binaries can damage the user’s machine. Remote execution could contain that damage, but the team leaves the local-versus-remote choice open. Either way, the system needs reversible execution: snapshots, checkpoints, rollback through an action sequence, and multiple rollouts—alternative attempts at completing the task. Remote hosting alone does not provide those capabilities.

Each attempt also needs to become faster. A company speaker says Windsurf sometimes feels too slow and identifies retrieval and generation as targets for systems and modeling work. A further ambition is to infer an ongoing change and suggest the remainder of a pull request without being asked. That remains a future direction, with no committed delivery date.

The model dropdown hides a division of labor

Codeium’s own models power autocomplete and Supercomplete on every keystroke. The rationale is specialization: the speakers connect fill-in-the-middle capabilities to token ordering. The speakers judge contemporary general-purpose models weak at this task and imprecise at localized edits. For high-level planning, however, they favor Claude and OpenAI’s models available at the time.

Retrieval is another focus for custom models. The motivating query is to find every quadratic-time algorithm in a codebase. A speaker argues that embedding similarity may miss the computational property being requested, both returning irrelevant code and overlooking relevant code. This is an argument for richer retrieval, not a measured comparison. Codeium says it runs custom models across large codebases using distributed systems.

A preview user had assumed the Claude and 4o dropdown described the whole system. The clarification is that external models handle high-level planning, while proprietary systems retrieve context and apply plans to the codebase. The retrieval principle is to distribute computation over raw data rather than rely only on a precomputed representation. A participant draws a loose comparison to ColBERT; the exchange establishes a possible resemblance, not that Codeium implements it.

Shared infrastructure, different economics

Codeium says individuals and enterprises use the same underlying infrastructure. Building indexing and model serving internally added complexity, but allowed enterprise deployments to use the system already serving the broader user base. Individual usage supplied product feedback and a capacity argument when prospects asked about supporting tens of thousands of developers. The team acknowledges that faster approaches were possible and that not every architectural choice was deliberate.

The commercial bet rests on switching costs. Individual developers could readily leave Codeium, so the company prioritized product quality over high margins. Deeper enterprise requirements appeared to offer more durable differentiation, with buyers less sensitive to small seat-price differences. Invoking Seven Powers, a participant argues that the product first needs to give people reasons to adopt it and stay.

At the time, Windsurf inherited Codeium’s $10-per-month Pro plan, described as primarily covering costs. Infrastructure efficiencies supported free unlimited autocomplete and chat on faster models; Supercomplete and large-scale indexing incurred meaningful costs that motivated the paid tier.

The pricing discussion also challenges uniform productivity calculations. Equally paid engineers may contribute very different value, making a flat percentage improvement a weak account of economic impact. The response defends per-seat pricing through blended team outcomes: a lawyer may get much more value from Microsoft Word than another employee paying the same price. These are arguments about uneven value, not measured productivity or compensation results.

Parallel trajectories meet environment bugs

Codeium had explored multiple agent trajectories internally: test different hypotheses and select a promising result. Parallel execution had not shipped because of side effects, missing functionality, and latency. A speaker argues that small, predominantly I/O-bound reads and writes need not require a separate machine for every trajectory. That claim concerns local operations around the codebase, not the compute required for model inference.

The roadmap extends the same ingredients: retrieval from additional data sources, stronger tool execution, richer records of human actions, and a simpler interface. A proposed Cascade experience would explore possible next steps and offer them as soon as the user opened it. The team jokes about Clippy returning, while explicitly saying this proactive interface does not yet exist.

Immediate priorities are more ordinary: slow operations, poor language support, failures on particular Windows versions, virtual-environment problems, and confusion about where terminal commands run. Daily internal use provided feedback, but a Mac-heavy team had Windows blind spots. WSL support was still missing at the time. These environment problems limited the usefulness of an otherwise ambitious agent.

Anshul reiterates that Windsurf does not mean expecting every enterprise customer to switch editors. Eclipse remains important, and extensions continue alongside the IDE. Codeium combines dedicated engineering for enterprise requirements with tools developers want to use. A company speaker reports reaching $10 million in enterprise annual recurring revenue in less than a year, attributing part of that growth to developer enthusiasm.

What the team changed its mind about

Codeium’s move from GPU virtualization into developer tools required the engineering team to adapt quickly. Its speakers resist presenting the resulting strategy as inevitable: enterprise knowledge came partly from lost deals, unexpected lessons, and luck.

Revisiting earlier advice about AI products, a company speaker retains the emphasis on context selection. Larger context windows still leave the task of assembling relevant knowledge distributed across enterprise codebases. But the blanket preference for first-party models is withdrawn. Specialized autocomplete may warrant custom models; improvements from external providers made Cascade and Windsurf possible.

Another mistaken assumption came from limited internal use of standalone ChatGPT. Experienced engineers already searched and navigated code efficiently, while a separate chat interface required substantial manual context preparation. That encouraged a belief that always-present passive assistance would advance ahead of active systems. A company speaker says Cascade overturned the assumption, gaining use even among the strongest AI skeptics.

Those skeptics serve as a product-quality check. Colleagues with autonomous-vehicle experience demand practical usefulness and reject weak ideas. The proposed balance pairs ambitious believers with people who insist the product earn its place in their work. The company also commits to launching without waitlists, preferring a reputation for being boring to uncertain launches.

Acceptance is the beginning of feedback

Asked whether interaction trajectories could justify more first-party modeling, the team emphasizes customer trust and points to user preferences as usable feedback. Codeium reports that synthetic data and preference data materially improved Supercomplete, without quantifying the gain. This describes learning from preference signals; it does not establish training on raw customer code.

The useful signal is what happens after acceptance. A developer may accept a suggestion and then delete several parts. An acceptance-only metric misses those corrections; subsequent edits reveal more about the eventual work product. The extension already supplied this feedback. Windsurf adds visibility into interactions such as opening the file explorer, providing further clues about intent.

Interaction costs matter at smaller scales too. Terminal assistance can remove a search for an unfamiliar Bash command; autocomplete-style help avoids opening another interface. A participant’s complaint about Warp illustrates the cost of inconsistent modes: natural language prefixed with # reportedly returned a command, while automatically detected natural language generated a flow. Similar inputs produced confusingly different behavior.

The discussion returns to three Ps of AI user experience: present, practical, and powerful. Practical improvements retain value as agents become more capable. Cascade combines streamed changes, navigation to diffs, background terminal execution, and visibility into running processes. These small mechanisms make work easier to follow and review; the team sees their combination as an early step toward a more powerful interface.

Enterprise architecture is a long-term capability

Codeium presents a durable, cash-generating business as the means to fund sustained investment in software development tools. An interviewer connects that ambition to architecture: security, compliance, personalization, usage analytics, latency budgets, and scale impose early costs, but postponing them can force changes to the product itself.

The company offers its then-ongoing FedRAMP accreditation process as an example. Its containerized system and deployment flexibility reportedly led collaborators to expect an easier process than starting from a monolithic hosted service. Accreditation was still underway, and early preparation had not eliminated redesign: Codeium had already encountered systems needing rearchitecture. Establishing the priorities early helped the team approach those changes.

The build-versus-buy rule is selective. Buy undifferentiated capabilities—Salesforce is the example—when building a substitute would waste effort. But outsourcing can also forgo expertise that is difficult to rebuild. Codeium cites its custom model-inference runtime as a capability worth retaining. The test is whether the team can realistically keep pace and whether the capability will differentiate the business over five to ten years. Temporary inferiority may be acceptable; an honest conclusion that the team cannot compete should favor buying.

Serving individuals and enterprises also requires cultural commitment. Enterprise requirements may do little for consumer growth metrics, making them hard to prioritize if the original team never valued them. Codeium describes deliberately learning enterprise sales and hiring for missing skills. First-principles reasoning helps set direction, but cannot anticipate every competitor or change in the AI market; adaptability remains necessary.

Sales remains part of the engineering feedback loop

The closing discussion treats sales leadership as an organizational design problem. A strong individual representative is not automatically equipped to build a scalable team. The job requires intellectual curiosity, sound hiring and economics, and technical education that keeps pace with the product. Codeium says buyers want to understand how its AI works, and describes Anshul working closely with sales to explain the technology and new capabilities.

Before hiring a sales leader, Codeium reports selling to roughly 30–40 customers and personally working through hundreds of deal cycles. That experience taught the team which messages worked and helped them judge whom to hire. Building a sales organization did not end engineering participation. Deployed engineers partner with account executives on technical questions, help customers succeed, and investigate where AI creates value.

The company speakers say they continue joining deal cycles because customer conversations inform what to build next. When another participant closes with a prediction of a future ten-billion-dollar valuation, the responses avoid adopting the target and joke about trying not to become a zero-billion-dollar company.