# Windsurf everywhere, doing everything, all at once

Kevin Hou, Windsurf

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/JVuNPL5QO8Q-windsurf-everywhere-doing-everything-all-at-once) · [Video](https://www.youtube.com/watch?v=JVuNPL5QO8Q)

## 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.

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?

[0:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=50s)

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](https://windsurf.com/events/aieworld), 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.”](https://ai.engineer/api/talk-essay-media/839cc87b6d0f72c7b8843c1b115f40518abd15116fc26483f87dfc54896f4d42)

Windsurf’s user growth slide charts daily code generation and reports 1,100 messages every minute.

### A shared timeline of human and AI actions

[2:30](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=150s)

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.](https://ai.engineer/api/talk-essay-media/e483f7c447154f54ead95ca07e97eec56b6eae039815908c1d91cd080bf5d151)

The workflow timeline includes actions inside and outside the IDE.

### The context behind a correct change

[3:55](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=235s)

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.

### A dashboard page begins before anyone writes code

[5:02](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=302s)

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.

### From reading the workflow to acting within it

[6:19](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=379s)

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.

### From synchronous assistance to background work

[8:37](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=517s)

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.](https://ai.engineer/api/talk-essay-media/e6c947129fca461532a027b9e16099906c8571c580e356194a8cda5310dcf9b8)

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?

### Engineering tasks do not always start at the beginning

[10:02](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=602s)

A workflow spanning these tools is more complicated than a competitive programming problem. Hou also points to the limits of relying on [SWE-bench](https://arxiv.org/abs/2310.06770) 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.

### SWE-1: evaluate completion and continuation

[11:21](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=681s)

**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.

| Evaluation | Starting point | What it tests |
|---|---|---|
| End-to-end task | Intent and an initial codebase | Complete a PR-like task and pass unit tests |
| Conversational SWE task | Existing conversation or partial task | Continue 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.

### Product use reveals what the model and tools are missing

[12:51](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=771s)

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.

### Align the application with the behavior the model should learn

[14:25](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=865s)

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.”](https://ai.engineer/api/talk-essay-media/d7457fd46d17872e84a4d4bd8807794994c99ea1a6b8cbb2e0592bcc52bf882c)

The closing thesis connects model, data, and application.

## Resources

- [SWE-bench: Can Language Models Resolve Real-World GitHub Issues?](https://arxiv.org/abs/2310.06770) — The original repository-level benchmark asks models to resolve real GitHub issues by editing code.
- [Cascade MCP integration](https://docs.devin.ai/desktop/cascade/mcp) — Current instructions for connecting Cascade to MCP servers, configuring tools and controlling team access.
- [Terminal execution controls](https://docs.devin.ai/desktop/terminal) — Current terminal documentation explains automatic execution settings and command approval controls.
- [Deploy applications through Cascade](https://docs.devin.ai/desktop/cascade/app-deploys) — Current Netlify deployment instructions cover public previews, project claiming and security considerations.

## Slides

### Windsurf everywhere, doing everything, all at once

Kevin Hou opens beside a windsurfing photograph, comparing the industry’s rapid movement to being on a kite on the ocean.

[0:33](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=33s) [Title slide beside a windsurfing photograph, with Kevin Hou credited as Head of Product Engineering.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ba53863351cb66b506b6f8c478be4ee1dca380dc2af5345201b3c507ed93317.webp)

Windsurf
everywhere
doing everything
all at once

Kevin Hou | Head of Product Eng

Interface text:
AI Engineer
World’s Fair
aws
WINDSURF EVERYWHERE, DOING EVERYTHING,
ALL AT ONCE

### The Windsurf Editor

The editor pairs code changes and accept/reject controls with Cascade, a panel for requesting changes across a codebase. Hou says the editor is used by millions of people worldwide.

[0:56](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=56s) [Windsurf Editor slide describing an agentic IDE, above a dark editor and Cascade interface screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e573074c09f88b2703d06ed1efcfd3c264a1c55a2731b4371df6cefbbd90c4c.webp)

The Windsurf Editor

The first agentic IDE, powered by a robust context engine and seamless multi-file editing.

app = FastAPI(
    title="Windsurf Backend",
    description="A fast backend API for the Windsurf app",
    version="0.1.0"
)

# CORS middleware (for frontend-backend communication)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.on_event("startup")
async def on_startup():
    await init_db()
    print("App is up and running!")

app.include_router(router, prefix="/api")

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
3
windsurf - main.py
Explorer
windsurf
models.py
main.py
Cascade | Write mode ([illegible])
Accept
Reject
Write with Cascade
Kick off a new project or make changes across your entire codebase
Add request logging middleware
Write
Chat
Claude 3.7 Sonnet
Image
Past Conversations
Add unit tests for the function I just wrote
Deploy my app to Netlify
Add a rotating glowing effect animation to my primary CTA
Keep Changes
Discard
Edited Files 1/1

### Launched 6 months ago

Team and office photos accompany Windsurf’s Nov 13, 2024 launch date. Six months later, the speaker says the company had retired the Codeium name.

[1:14](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=74s) [Slide showing the November 13, 2024 launch date and two photographs of the team.](https://assets.ai.engineer/sites/aiecode2025/sha256/6ef4e3fa6b73b90f1e0e910e87924b97bfb15f0e1656ec1368159ef60c220ab4.webp)

Launched 6 months ago
Nov 13, 2024, 6am PT

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

[1:18](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=78s) [Windsurf launch date, November 13, 2024, with team and office photos.](https://assets.ai.engineer/sites/aiecode2025/sha256/b0775005832bdf1b9910ad8260ffd8a9ac48d425fe420638c1234b611a2b926b.webp)

Launched 6 months ago
Nov 13, 2024, 6am PT

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
aws
WINDSURF EVERYWHERE, DOING EVERYTHING, ALL AT ONCE

### Pace of Innovation

Windsurf charts nine release waves from its November 2024 launch through May 2025, adding web search, MCP support, deploys and simultaneous Cascades along the way.

[1:40](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=100s) [Timeline of Windsurf launch and nine release waves from November 2024 through May 2025.](https://assets.ai.engineer/sites/aiecode2025/sha256/3d7b8556f055b815cfce2ac185d49faa80be2f0b284f8406676f73100cbc5749.webp)

Pace of Innovation
9 “waves” in the last 7 months

Launch — Nov 2024
Development began in September

Wave 1 — Dec 2024
Cascade Memories
WSL support
Image input

Wave 2 — Jan 2025
Web Search
Automated Memories
Problems Tab
Explain Problem UI

Wave 3 — Feb 2025
MCP Support
Tab to Jump
Turbo Mode

Wave 4 & 5 — Mar 2025
Previews
Tab to Import
Linter integration
Suggested Actions
Windsurf Tab

Wave 6 & 7 — Apr 2025
Cascade for Jetbrains
Commit message generation
Explain Problem UI
Deploys

Wave 8 & 9 — May 2025
Custom workflows
Windsurf Reviews
Knowledge base
SWE-1
Simultaneous Cascades

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
aws
WINDSURF EVERYWHERE, DOING EVERYTHING, ALL AT ONCE

### Shared timelines between human and AI

Windsurf frames the engineer’s work and AI as a shared timeline. Hou says this can make the AI feel like it is reading the user’s mind.

[2:33](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=153s) [Slide describes shared timelines between humans and AI as Windsurf's secret sauce.](https://assets.ai.engineer/sites/aiecode2025/sha256/373eab6df946423735b7925d5f37adf444dbdf9087d3895ba232b67995bc0514.webp)

Our secret sauce

Shared timelines between human and AI

AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

Interface text:
AI Engineer World’s Fair
Engineering the future of AI

### Developer workflow inside and outside the IDE

The timeline places IDE actions such as research and editing alongside work in Figma, source control, CI, and other tools. Windsurf argues that its timeline needs to handle actions outside the IDE too.

[3:28](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=208s) [A workflow timeline shows IDE actions alongside external tools including design, source control, CI, browser, chat and issue tracking.](https://assets.ai.engineer/sites/aiecode2025/sha256/f7a616716278357e5f82dedc478ac3272dd6e34939f3a4586d1cb611774d4232.webp)

But what else does a human do beyond just write code in their editor?

Actions outside of the IDE
Figma
SCM
CI
Browser
Slack
Linear / Jira

Timeline actions: Navigate; Research; Edit; Edit; Edit; Suggest Execution; Guide; Add File; List Dir; Edit

Navigate: Cascade
Research: Cascade
Edit: Autocomplete
Guide: Cascade

All these actions are contained within the IDE

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Where is Windsurf headed next?

Windsurf’s vision starts with a question: how should it serve developer workflows that extend beyond the IDE?

[3:47](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=227s) [A vision slide asks where Windsurf is headed given how much developer work happens outside the IDE.](https://assets.ai.engineer/sites/aiecode2025/sha256/6572492b33086ca3ea043b3b66778e1ac908638ca2348b09aa78f354bb0346da.webp)

Vision

Given how much of the developer workflow happens outside the IDE, where is Windsurf headed next?

AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

### Windsurf will be everywhere

Windsurf’s vision extends beyond the IDE: it aims to read and ingest context from every source a developer uses.

[3:53](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=233s) [Section slide stating that Windsurf will be everywhere.](https://assets.ai.engineer/sites/aiecode2025/sha256/26398afd54418f9e84393e9a4668f88a98568c0e8139498b175120064ff731b0.webp)

{01}
Windsurf will be everywhere

AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

### Read and write actions

Windsurf aims to ingest context from tools across a developer’s workflow. The diagram highlights read sources and shows a dimmed range of write actions, from generating designs to deploying an app.

[4:01](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=241s) [A diagram lists sources Windsurf can read and actions it can perform.](https://assets.ai.engineer/sites/aiecode2025/sha256/46c1a0145cfb31bfd1bb7e4e686e1d57fdd1c830ebd855e0596d5586b503c952.webp)

AI ENG WORLD’S FAIR | WINDSURF | JUNE 2025 | 4

Read Actions
Active Repo
Terminal history
Figma
Slack
Linear / Jira
CI
SCM
Browser
Research

Write Actions
Generate Design
Write PRD
Run Terminal
Create & Edit Files
Provision API Key
Make PRs
Review PRs
Deploy app

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai
neo4j

### Context sources for software engineering

Windsurf aims to use coding activity, external research, experience, notes and preferences as context, like a pair programmer. The speaker calls the experience and preferences layer “meta learning.”

[4:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=290s) [A slide lists coding activity, external sources, experience, notes, and user preferences as context.](https://assets.ai.engineer/sites/aiecode2025/sha256/4858fee9c1b3534bf58e643e40839bee2ce7f31b9f121718039facb582fce8da.webp)

What makes a SWE successful?

We aim to feed these sources into Windsurf as contextual signals—just like a pair programmer would naturally pick up on.

File reads
Workspace edits
Terminal command history
Currently open files

Git commit logs, blames, PRs, etc.
File browsing history
Web search
Documentation

Years of experience (ie. auto-generated memories)
Personal notes files (ie. rules files)
User preferences

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
Engineering the future of AI

### Building a dashboard page

A dashboard page draws on requests in Slack, architecture in Google Docs, requirements in Jira, and designs in Figma before coding in Windsurf. The work continues with GitHub PRs and analytics.

[5:17](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=317s) [A dashboard example maps requests, architecture, requirements, designs, and coding to different tools; lower content is clipped.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6d5922afd8a870a7c4f7b2f88664b288fdc30edd76d5332c1be22c3a219b440.webp)

Example – You’re building a new page on a data visualization dashboard

Custom requests - Slack
Architecture knowledge - Google Docs
Frontend/Backend requirements - Jira
Frontend designs - Figma
Write & generate the code - Windsurf
PRs and code management - Github
User analytics - Google

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

### Windsurf will do everything

Windsurf’s vision extends beyond reading context: the AI should also take actions across the tools a software engineer uses.

[6:25](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=385s) [A section slide reads “Windsurf will do everything” over a dotted wave pattern.](https://assets.ai.engineer/sites/aiecode2025/sha256/0277758a420a8ff6d9aae050a6bfc36d94fe284d23014ffa42529d30aa5abdd6.webp)

AI ENG WORLD’S FAIR    WINDSURF    JUNE 2025    4

{02}
Windsurf will
do everything

AI Engineer
World’s Fair
Engineering the future of AI

### Read and write actions

Windsurf’s vision pairs reading context from tools like Figma and Slack with actions from generating designs to deploying apps, extending AI work beyond coding.

[6:32](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=392s) [Two rows list sources Windsurf can read and actions it can perform, from generating designs to deploying an app.](https://assets.ai.engineer/sites/aiecode2025/sha256/be9b247b68ba7f8214cdfab1558a78071787859f6298e939cb5085f3619e9466.webp)

AI ENG WORLD’S FAIR    WINDSURF    JUNE 2025    4

Read Actions
Active Repo
Terminal history
Figma
Slack
Linear / Jira
CI
SCM
Browser
Research

Write Actions
Generate Design
Write PRD
Run Terminal
Create & Edit Files
Provision API Key
Make PRs
Review PRs
Deploy app

Interface text:
AI Engineer World’s Fair
Microsoft
aws
smol ai

### Iterating on the web app

Windsurf Browser Previews let the developer send DOM elements, console logs and screenshots to the agent while iterating on the web app. The slide identifies this as a Wave 4 release.

[7:21](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=441s) [Browser previews send DOM elements, console logs, and screenshots to Windsurf.](https://assets.ai.engineer/sites/aiecode2025/sha256/82e92eb0acca22a54d7605f4d1bd29f727de362433e98c494135f9ea3af557eb.webp)

AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4

Windsurf building a web app end to end
Iterating on the web app

Hello, I'm Yash
Designer & Developer creating digital experiences with a tactile, riso-printe[illegible]

Send DOM elements to Windsurf
Send console logs to Windsurf
Send screenshots to Windsurf

Browser Previews for quick iteration and debugging (released Wave 4)

Interface text:
Select element
Send logs
Screenshot
Capturing full page screenshot...
[illegible console text]

AI Engineer World’s Fair
Engineering the future of AI

### Windsurf everywhere, doing everything

Windsurf’s depicted workflow spans reading repositories, terminal history and tools such as Figma and Slack, then taking actions from writing a PRD and editing files to reviewing PRs and deploying an app.

[8:31](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=511s) [Two rows list sources Windsurf can read and development actions it can perform.](https://assets.ai.engineer/sites/aiecode2025/sha256/fdd8257264997667401627f86cb8352b187147cad691a9cde1caccf7ed232062.webp)

Windsurf everywhere, doing everything.

Read Actions
Active Repo
Terminal history
Figma
Slack
Linear / Jira
CI
SCM
Browser
Research

Write Actions
Generate Design
Write PRD
Run Terminal
Create & Edit Files
Provision API Key
Make PRs
Review PRs
Deploy app

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
Engineering the future of AI

[8:36](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=516s) [Two timelines list Windsurf read actions and write actions across software development tools and workflows.](https://assets.ai.engineer/sites/aiecode2025/sha256/9f3b412ebe4db7c86ed031fbbce2d88643d062aa66cb8c364e0aed3d75a8bda0.webp)

Windsurf everywhere, doing everything.

Read Actions
Active Repo
Terminal history
Figma
Slack
Linear / Jira
CI
SCM
Browser
Research

Write Actions
Generate Design
Write PRD
Run Terminal
Create & Edit Files
Provision API Key
Make PRs
Review PRs
Deploy app

Interface text:
AI ENG WORLD’S FAIR
WINDSURF
JUNE 2025
4
AI Engineer World’s Fair
Engineering the future of AI

## Full transcript

[0:00](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=0s) [upbeat music] Hello. [audience applauding]

[0:18](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=18s) How we doing? All right. How's the-- How's the energy level? We're [laughs]

[0:25](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=25s) good. Good. Yes. Let's go, let's go. Two more, two more. My name is Kevin. I lead product at Windsurf, and I'm super excited to be back here. Thank you so much, swyx and Ben.

[0:35](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=35s) It's always a pleasure to come back to AI Engineer World's Fair.

[0:39](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=39s) The velocity of our industry right now is incredible. It's like being on a kite on the ocean, and we're really excited to see where the winds are taking us.

[0:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=50s) A year ago, we didn't have Windsurf. People were coding with autocomplete. No one had heard of an agent. And now the Windsurf editor is being used by millions and millions of people all around the world.

[1:03](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=63s) And hopefully, this is a larger number than last time. How many people have heard of Windsurf, and how many people have used Windsurf?

[1:11](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=71s) Uh. [laughs] Good numbers, good numbers. We gotta, we gotta improve that.

[1:17](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=77s) And Windsurf itself has changed immensely in the last six months since its launch in November. We retired the name Codeium because we decided to catch this new wave,

[1:27](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=87s) which is, by the way, what we call our next generation innovations in the product. We call them waves. And in case you missed it, we are now ten waves in.

[1:36](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=96s) And some of the key waves we've been really excited about: web search, MCP support, auto-generated memories-- Oh, I was supposed to do that. Auto-generated memories, deploys, and parallel agents, to name just a few.

[1:51](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=111s) And as the waves keep growing, as do the number of people that have discovered and integrated Windsurf into their work-- daily workflows. To this day, we are generating about ninety million lines of code every single day,

[2:04](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=124s) and that equates to around a thousand-- over a thousand messages sent every single minute. But today is not about growth. I'm not gonna sit here and tell you about the numbers.

[2:14](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=134s) I'm gonna tell you about the why. Why do people feel connected to the Windsurf editor?

[2:20](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=140s) And I know no AI company really wants to disclose its secrets, but I had to come up with some content.

[2:26](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=146s) So today I'm gonna let you in on one of ours.

[2:30](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=150s) Our secret sauce is a shared timeline between the human and the AI, and this is what makes people feel like we're reading their minds.

[2:40](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=160s) And now everything you do as a software engineer can be thought of on this shared timeline. So if we rewind way back to the dark days, this is pre-autocomplete when everyone knew how to write a for loop.

[2:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=170s) You had to do everything. You had to edit files, you had to type every single character. Imagine that. But then once services like Copilot, like Codeium, they launched and devs got really excited.

[3:02](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=182s) They started seeing a small percentage of their code being written by AI, and we started to abstract and accelerate the number of small edits, small actions that we would do for a user.

[3:12](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=192s) And in late twenty-twenty-four, with the advent of Windsurf's agent and the launch of the Windsurf editor, we saw that we could do more and more for the user. We started being able to edit multiple files at once, perform background research across thousands and thousands of files, and execute terminal commands directly inside the editor.

[3:32](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=212s) But at Windsurf, we're in the business of trying to change how software gets created, and this means that the timeline is actually a little bit more complicated. It needs to handle actions taken outside of just the IDE.

[3:47](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=227s) And so given how much of a developer's workflow happens outside of the editor, what does this mean for Windsurf?

[3:55](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=235s) First, Windsurf is going to be everywhere. Specifically, Windsurf will need to be able to read and ingest context from every single source that a developer uses.

[4:08](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=248s) And if we zoom out and think about what makes you all software engineers successful, there are a couple of different categories. The first of which, coding related. File reads, running terminal commands, seeing your history, even, you know, which tabs you have open inside of your editor.

[4:23](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=263s) This all informs how to generate the correct code. But it goes beyond that. There's external sources, things like going onto GitHub and viewing a past history of commits. Maybe looking at a PR that is doing something similar to the feature you're about to implement.

[4:37](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=277s) Doing online searches, web searches, looking at documentation.

[4:42](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=282s) And then there's the third category, and this is where it gets a little bit interesting. It's called meta learning. It's the idea of what separates a junior engineer from a senior engineer from a staff engineer.

[4:53](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=293s) These are the organizational best practices, the engineering preferences that all get encoded into what makes good code.

[5:02](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=302s) And so if we think about what this means in practice, let's say that we are going to build a new page on a data viz dashboard. Let's walk through step by step.

[5:09](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=309s) So first, you would probably start in Slack, as all good things start from Slack. You'll build context looking at a bunch of maybe customer requests. Maybe you'll have some internal messages.

[5:18](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=318s) You'll collect that context, and you'll start planning. And this means you're gonna be in Google Docs. You're gonna be writing design docs, probably working on some infrastructure designs. You're gonna be tracking tickets inside of Jira.

[5:29](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=329s) And then you might have a designer who's actually working in Figma in parallel, putting together all this material. And then finally, the fun part, or at least this is my favorite part, which is the actual writing of the code, and hopefully you use something like Windsurf to do so.

[5:42](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=342s) But you're not done from there. Once your code complete, you still have to open the PR. You gotta get reviews. You gotta merge into main. You gotta deploy SEO, analytics.

[5:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=350s) The list goes on and on and on.

[5:53](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=353s) And this is really why we've built what we've built. Because we know that for you, it's extremely important that we can fetch context from your Google Docs, that we can read your Figma files.

[6:04](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=364s) And that we can one-click connect to any MCP service so that you can access your information in things like Notion, Linear, Stripe, and countless others. And we've spent the last ten waves making sure that Windsurf can be ubiquitous.

[6:19](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=379s) But we know that's also not enough. We know it's not enough just to read. We need to be able to do and write everything. We need to be able to do it all for you.

[6:30](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=390s) And so the AI has to take action on a wide variety of surfaces beyond just the coding surface in order to accomplish what a human software engineer would do.

[6:40](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=400s) And so this doesn't mean just write code. This means interacting with third-party services, provisioning API keys, writing design docs, PRDs, wireframing, testing, and the list could go on and on and on.

[6:53](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=413s) And so for the last six months, we've oriented ourselves around how do we do everything.

[6:59](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=419s) And if we go back to this concrete example of building a new web app,

[7:04](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=424s) where do we start? We start by running codebase-relevant terminal commands. This is something that we launched right at the advent of Windsurf. And what's really cool about what we can do here is that we can intelligently decide which commands we want to run automatically and which ones we want to wait and ask for explicit user for

[7:20](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=440s) approval. Next, you'll open up Windsurf browser previews, which allows you to iterate from there. It allows you to visually iterate with the agent so that Windsurf can take control of Chrome just like you would, inspecting DOM elements, looking at your JS console, being able to do what a web developer would do.

[7:39](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=459s) And so now you could say our app is code complete. We'll use the GitHub MCP to open up a pull request, and we can use context from your other PRs to be able to inform the description and inform the test plan.

[7:52](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=472s) And code review is still a necessary part of any software company. And so we launched Windsurf Reviews, which can automatically leave comments and suggest changes asynchronously so that you can be confident that the code that hits main is production ready.

[8:09](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=489s) And so now that your code is merged, you'll want to be able to deploy. And so we also released a one-click service to Netlify so that you can use Windsurf's custom tool integrations to actually just in one click, the agent will deploy what you have to the live web.

[8:26](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=506s) And so as you can see, we've really built the ability for Windsurf to read everything that you can and do everything, or almost everything, that a software engineer can.

[8:37](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=517s) So then you might ask, what's next? It's only inevitable that Windsurf will be on all the time, working for you even when you don't know it.

[8:49](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=529s) We pioneered the agentic human-in-the-loop synchronous workflows back when we released Windsurf in twenty twenty-four. And today, timelines are eighty to ninety percent agent, ten to twenty percent human. But we're trying to build towards a future that gets to ninety-nine percent agent and one percent human.

[9:08](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=548s) We only want to ask the user for final approval. And as more and more of these timelines and workflows become AI-powered, it becomes possible to have Windsurf working for you at all times, not only as you type and use auto-complete and tab, but also in the background, researching when you're working, fully in parallel, only asking you to

[9:28](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=568s) approve. And we want to build this future where you can code anytime. You can write software at any time. This includes your bed. This includes the toilet. When you're on the bus.

[9:40](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=580s) Voice-activated Alexa. The possibilities are endless. And so now that we've defined the problem, it's a little bit more structured. You could say, "All right, we'll throw GPT, we'll throw Gemini at this timeline problem."

[9:53](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=593s) But then from there, where do we go? How do we improve? And specifically, how is Windsurf able to tackle this problem of the timeline?

[10:02](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=602s) And if we take a step back, this really doesn't look like we're writing code anymore. This looks significantly more complicated than your average competitive programming question.

[10:14](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=614s) Windsurf wants to revolutionize the way that software gets built. It's not just how code gets written. We are solving a broader set of tasks than just code. And while the industry focuses heavily on things like SWE-bench, we know that the future is not going to be tokens in, tokens out.

[10:31](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=631s) Software engineering workflows are going to be much messier than this. It means that you have to be able to pick up tasks mid-workflow, you have to be able to deal with messy codebase states mid-commit, and you will have to work with tools that are outside of the editor.

[10:46](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=646s) And so we have to be able to ingest and perform over this broad set of actions on this timeline to keep our users in the flow. We have to be able to open up PRs.

[10:56](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=656s) We have to know when to access analytics. We need to know how to debug your CI/CD all by itself. And this problem starts to look really, really different from what people are evaling on.

[11:07](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=667s) And because we have our own representation of this timeline, we needed a different system to be able to handle these types of actions than what the off-the-shelf frontier models could give us.

[11:18](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=678s) And so where are we going with this?

[11:21](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=681s) The realization of this is our brand-new software engineering model called SWE-1. We realized ourselves that we could actually dream bigger and build the best software engineering model that we could.

[11:33](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=693s) SWE-1 is trained to handle software engineering workflows, not just purely code generation. And we use two main offline eval benchmarks. The first one, end-to-s-- end-to-end task benchmark. This is basically tackling pull requests.

[11:48](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=708s) This is saying, given an intent, given the starting point of a code base, how do we get to the end and pass all the unit tests? Familiar pattern.

[11:55](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=715s) The second one is where it gets a little bit more interesting. This is what we call a conversational SWE task benchmark. And this is how well the model can assist when it's being dropped into an existing user conversation or a partially completed task.

[12:10](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=730s) And so this actually r- lends itself very nicely to the Windsurf paradigm, right? Because we're not going cleanly from start to end, we're assisting and helping you along the way mid-timeline.

[12:20](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=740s) And so it results in this blended score of helpfulness, efficiency, and correctness, and really tests the model's ability to seamlessly integrate into the Windsurf style of working.

[12:31](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=751s) And this initial performance really gives us a lot of confidence in SWE-1's architecture, specifically how we've been able to train for software engineering workflows. And we've been able to achier- achieve near frontier model results at the fraction of the cost and with a significantly smaller team.

[12:51](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=771s) And one of Windsurf's greatest strengths, of course, is in the value of community: real software engineers doing real work, giving real feedback. And what we found is that SWE-1, it's in the little dropdown for the models, it's right up there with the rest of the frontier models.

[13:06](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=786s) People are choosing SWE-1 because it recognizes how they do work, not necessarily how to generate code, and it's contributing actually an even higher frequency than models like 3.7 and 3.5.

[13:22](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=802s) Windsurf builds at the frontier so that our users can build more with the best technology. We learn from our failure modes so that we can iterate from there. And what does this start to look like?

[13:35](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=815s) Dare I say it, a data flywheel. We ship the best product. Devs and non-devs use that product to level up as a skill multiplier or as a skill enabler.

[13:46](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=826s) Users then help us find the frontier. They use things like thumbs up, thumbs down, accept, reject, constantly informing us not of what the SWE-bench frontier is, but what is the software engineering frontier.

[14:00](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=840s) What tools are missing? Which workflows are repeated? Where does the product fall short?

[14:07](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=847s) And we take those insights, and we build at this frontier.

[14:12](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=852s) We train a better model. We build more tools. We improve our agentic harness. We improve our memories, our checkpointing, with the goal of being everywhere, doing anything.

[14:25](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=865s) And we will repeat this cycle. We will be shipping, finding the frontier, building at the margin, and repeating. And what gets me really personally excited about this is SWE-1 is really an example of this in action.

[14:39](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=879s) We have a very small team, significantly fewer resources than the larger companies, and we were able to achieve near frontier model quality results with SWE-1.

[14:50](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=890s) And even more so, this is really a demonstration of what it means to build AI products in 2025. It demands this harmony of model, data, and application, where the application is actually mimicking the user behavior that you want to replicate inside of your model.

[15:11](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=911s) And this is how Windsurf will be everywhere, doing everything all at once.

[15:19](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=919s) Thank you so much for listening. [laughs] And I won't give you any promises, but someone made a profit.

[15:36](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=936s) Um, but in all seriousness, thank you so much for listening. I want to make sure that every engineer out there is using the best possible tools. So please give Windsurf a try today, and we are also hiring across a number of different roles.

[15:48](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=948s) We have a booth downstairs, so please come join us. Help make this future a reality.

[15:55](https://www.youtube.com/watch?v=JVuNPL5QO8Q&t=955s) Thank you. [clapping] [upbeat music]
