AI Engineer World's Fair 2025

Windsurf everywhere, doing everything, all at once

Kevin Hou· Head of Product, Windsurf16:03

Loading slides…

Read the talk

Windsurf everywhere, doing everything, all at once

A coding agent needs more than repository context: it must follow work across tools, join partially completed tasks, and learn when to act or ask for approval.

From a talk by Kevin Hou

Before you start: Familiarity with code editors, pull requests, and deployment workflows is helpful; no model-training background is required.

Why does an editor feel like it understands your work?

What makes an AI editor feel connected to the way you work? Autocomplete established one kind of connection: it could anticipate the next small piece of code. In Kevin Hou’s Windsurf keynote, the starting point is how quickly that relationship expanded. Following the editor’s November 2024 launch and the retirement of the Codeium name, Windsurf added web search, Model Context Protocol (MCP) support, automatically generated memories, deployment, and parallel agents. Hou describes these releases as ten product waves.

Hou reports millions of users, about 90 million generated lines of code per day, and over 1,000 messages per minute. These are product scale claims from the presentation, without a counting methodology; generated code is not a measure of retained code or engineering productivity. The more useful question is what makes those interactions fit a developer’s daily workflow.

A rising line chart labeled “Lines of code generated by Windsurf every day,” alongside text reading “1,100 messages sent to Windsurf every minute.”Open full source frame
Windsurf’s user growth slide charts daily code generation and reports 1,100 messages every minute.
0:501:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:50 · section reference included

A shared timeline of human and AI actions

The organizing idea is a shared timeline between the human and the AI. Before autocomplete, the developer performed each edit. Autocomplete delegated small stretches of that activity to a model. With the late-2024 agent, Windsurf could take on longer sequences: editing multiple files, researching across thousands of files, and executing terminal commands inside the editor. The unit of assistance grew from a completion to a sequence of engineering actions.

That progression exposes the editor’s boundary. Software creation also includes actions in design tools, source control, CI, browsers, chat, and issue trackers. If the agent’s timeline stops at the IDE, it misses work that explains both what the developer wants and what should happen next. The timeline has to include work outside the editor.

A horizontal action timeline with Cascade and Autocomplete annotations below, and Figma, SCM, CI, Browser, Slack, and Linear / Jira above.Open full source frame
The workflow timeline includes actions inside and outside the IDE.
2:302:40
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:30 · section reference included

The context behind a correct change

Reading that broader workflow requires three kinds of context:

  • Coding activity: file reads, terminal commands, history, and even the tabs open in the editor. These indicate what the developer is currently investigating.
  • External sources: GitHub commit history, a similar pull request, web searches, and documentation. These supply precedents and information beyond the current files.
  • Organizational knowledge: engineering preferences and established practices. Hou calls this meta learning: the accumulated judgment that helps distinguish junior, senior, and staff engineers.

Correct code depends on more than syntax or local repository structure. It also depends on the conventions and decisions surrounding the task.

3:554:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:55 · section reference included

A dashboard page begins before anyone writes code

Consider adding a page to a data visualization dashboard. The work crosses several tools before the implementation is complete:

  1. Read customer requests and internal messages in Slack to establish the need.
  2. Write design and infrastructure plans in Google Docs, while tracking tickets in Jira.
  3. Incorporate the designer’s Figma work, which may proceed in parallel.
  4. Write the code in the editor.
  5. Open a pull request, obtain reviews, merge into main, and deploy. SEO and analytics still follow.

The code is one stage in a longer process. An agent that sees only the implementation cannot directly use the requirements, planning decisions, or design context that preceded it.

This is the practical reason for fetching Google Docs context, reading Figma files, and connecting to MCP services. Hou describes one-click connections to services such as Notion, Linear, and Stripe as ways to make the information available where the developer is working. The integrations and behavior described here are the keynote’s Windsurf product experience; later documentation and product naming should not be read as its historical contract.

5:025:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:02 · section reference included

From reading the workflow to acting within it

Access to context solves only the reading side. Completing engineering work also requires actions in third-party services: provisioning API keys, writing design documents and product requirements, wireframing, and testing. Each adds a surface on which an agent must do something, rather than simply describe what a human should do.

Returning to the web app, the first action is running codebase-relevant terminal commands. Windsurf can distinguish commands it should execute automatically from commands that should wait for explicit user approval. Browser previews then extend the iteration loop into Chrome: the agent can inspect DOM elements and the JavaScript console while the developer works through visual changes. The browser supplies evidence about the running application that source files alone cannot provide.

Once the app is code complete, the GitHub MCP integration can open a pull request. Other PRs supply context for its description and test plan. Windsurf Reviews then adds asynchronous comments and suggested changes. Review remains part of the workflow; production readiness is the intended outcome, not something guaranteed by automated comments.

After merge, a custom Netlify integration lets the agent deploy the app to the live web in one click. That completes the sequence from local implementation through review to a public deployment, although publishing an app does not itself establish production readiness. Hou’s qualification matters: this is coverage of almost everything an engineer does, rather than a claim that every engineering responsibility has been automated.

6:196:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:19 · section reference included

From synchronous assistance to background work

Once the agent can read context and perform actions across those surfaces, the next ambition is to keep it working between direct interactions. Hou characterizes the then-current timelines as 80–90% agent and 10–20% human, with a future target of 99% agent and 1% human. He supplies no denominator or measurement method for those shares; the target expresses a desired reduction in required human intervention.

The proposed interaction is background work with final human approval. Research could proceed alongside the developer’s active work, while other workflows prepare results for approval. The slide makes this concrete with debugging, building a new web page, and background research branching from a central timeline; debugging and page building include human approval steps. This is the always-on direction Hou wants to build toward, not a demonstration that the entire workflow already operates unattended.

Dashed boxes show debugging, building a new web page, and background research workflows branching from a central timeline. Debugging and page building include human approval.Open full source frame
Three asynchronous workflows branch from a shared timeline, with human approval steps shown.

That direction also loosens the connection between software creation and sitting at an editor. Hou imagines working from a bus or through a voice interface such as Alexa. But choosing a general model—GPT or Gemini, for example—does not answer the next question: how do you improve its ability to operate on the timeline itself?

8:378:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:37 · section reference included

Engineering tasks do not always start at the beginning

A workflow spanning these tools is more complicated than a competitive programming problem. Hou also points to the limits of relying on SWE-bench as the central measure of progress. The distinction is about coverage: repository issue resolution is valuable, but an agent also has to pick up an existing conversation, work with partially changed code mid-commit, and use tools outside the editor.

Those situations require decisions beyond producing a correct patch. The agent must know when to open a PR, when to consult analytics, and how to debug CI/CD. It has to act from the state the developer actually left behind. Hou connects this requirement to Windsurf’s own timeline representation: the company wanted a system trained for those actions, beyond what it was getting from off-the-shelf frontier models.

10:0210:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:02 · section reference included

SWE-1: evaluate completion and continuation

SWE-1 is Windsurf’s response: a model trained for software engineering workflows, not only code generation. Hou describes two offline evaluation modes that test different starting conditions.

EvaluationStarting pointWhat it tests
End-to-end taskIntent and an initial codebaseComplete a PR-like task and pass unit tests
Conversational SWE taskExisting conversation or partial taskContinue helpfully, efficiently, and correctly

The first follows a familiar path from request to completed change. The second asks whether the model can join work already in progress. Its blended assessment of helpfulness, efficiency, and correctness reflects the need to assist mid-timeline, where reaching the right result is only part of being a useful collaborator.

Hou claims near-frontier results at a fraction of the cost with a significantly smaller team. The presentation does not supply numerical scores, a cost basis, or team size, so this is a vendor characterization of selected evaluations rather than evidence of universal parity. The technical point is the choice of training and evaluation target: continuing engineering work, as well as completing it from a clean starting point.

11:2111:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:21 · section reference included

Product use reveals what the model and tools are missing

Inside the product, SWE-1 sits in the model selector alongside frontier alternatives. Hou reports that SWE-1 contributes at a higher frequency than the models he calls 3.7 and 3.5. The talk does not define that metric or its comparison conditions, so it should not be read as a general productivity or user-preference ranking. Its role in the argument is to connect workflow-oriented training with behavior observed in the application.

That application supplies a feedback loop. Developers can use it to multiply existing skills; non-developers can use it to attempt work they could not previously do. Their thumbs-up, thumbs-down, accept, and reject actions help expose where the product falls short. Repeated workflows and missing tools become concrete targets for improvement, rather than merely another benchmark score to optimize.

The response can happen at several layers: train a better model, add tools, improve the agentic harness, or strengthen memories and checkpointing. A failure in an engineering workflow is therefore not automatically a model-only problem. Product feedback helps identify which part of the system needs to change.

12:5113:06
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:51 · section reference included

Align the application with the behavior the model should learn

The cycle repeats: ship the product, discover the limits users encounter, improve at those limits, and ship again. Hou presents SWE-1 as an example of that process under a small team’s resource constraints. The product is both where the model helps people and where the next set of engineering problems becomes visible.

The closing design principle is that model, data, and application must develop together. The application should reflect the user behavior the model is meant to learn. If the desired behavior is to continue a partially completed task, use external tools, and collaborate at approval points, those interactions need to exist in the product itself. The shared timeline gives that ambition a concrete shape: software engineering as an evolving sequence of human and AI actions, rather than a succession of isolated code-generation requests.

Slide linking “Model,” “Data,” and “Application,” with the statement “Application must mimic the behavior that we want to encode in the model.”Open full source frame
The closing thesis connects model, data, and application.
14:2514:39
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:25 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…