AI Engineer Summit 2025
Agents are built at the fringe: getting from 90 to 100
Read the talk
Building agents that understand the developer’s next move
Windsurf’s early demos show how shared activity history, persistent context, and model-directed research turn code generation into a coordinated development workflow.
From a talk by Kevin Hou
Before you start: Familiarity with code editors, package managers, and basic LLM tool use will help you follow the demonstrations.
What comes after completing the next function?
If an AI can finish your function, what must change before it can continue your work? In 2022, Copilot’s ghost-text suggestions made AI assistance tangible: write some code, see a completion, press Tab. Codeium followed with autocomplete extensions for VS Code, JetBrains, Vim, and Emacs. Kevin Hou, Windsurf’s product engineering lead, reports that those extensions attracted a couple million users.
Autocomplete was a useful starting point, but its interaction model assumed relatively small contributions from the model. Larger models, better training, reinforcement learning, and tool use suggested a different division of labor. Instead of repeatedly accepting completions or copying answers from ChatGPT, developers could delegate longer stretches of work. In this first Windsurf presentation, Hou treats even the IDE as a potentially temporary interface: the enduring objective is to build the best software-development experience as the underlying intelligence improves. By early 2025, that direction had become an agentic editor.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Build the crawler where the developer works
The first demonstration asks Cascade, Windsurf’s sidebar agent, to build a Python web crawler that produces statistics about a website. The work extends beyond generating a source file: Cascade installs dependencies with pip, sets up a virtual environment, and proposes edits with accept and reject controls. Its commands appear in the developer’s interactive terminal, where the developer can inspect and intervene in the work.
A small Python example makes the crawler’s division of responsibilities concrete: fetch a page, parse it, and report a statistic. This illustrates the task rather than reproducing the displayed web_crawler.py:
python
from html.parser import HTMLParser
from urllib.request import urlopen
import sys
class LinkCounter(HTMLParser):
def __init__(self):
super().__init__()
self.links = 0
def handle_starttag(self, tag, attrs):
if tag == "a" and any(key == "href" for key, _ in attrs):
self.links += 1
def page_stats(url):
with urlopen(url, timeout=10) as response:
body = response.read()
charset = response.headers.get_content_charset() or "utf-8"
parser = LinkCounter()
parser.feed(body.decode(charset, errors="replace"))
return {"bytes": len(body), "links": parser.links}
if __name__ == "__main__":
print(page_stats(sys.argv[1]))
Writing the function is only part of the agent’s job. The surrounding workflow must also make its environment, execution, and proposed changes visible.
The editor also supports documentation lookup, web search enabled by default, codebase searches with grep, generated commit messages, and image drag-and-drop. The selected crawler frame shows why these capabilities belong together: web_crawler.py appears beside a terminal traceback and Cascade’s repair-and-rerun steps. It captures an intermediate debugging state, not a completed statistics report.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Less explicit input, more operational responsibility
The product objective is to minimize explicit input while producing correct, production-ready code. That means absorbing work developers otherwise do between coding steps: reading stack traces, finding the original source that needs changing, and retrieving documentation for the right package version. Background research and next-step prediction should let developers spend more attention on features and products, with fewer interruptions to assemble context for the agent.
Windsurf launched on November 13, 2024, roughly three months before this presentation. Hou reports 4.5 billion lines of code generated during those first three months. Requests to Cascade included refactors, new features, and new website pages. The figure describes generated volume; the talk does not specify how much was accepted, retained, or regenerated.
That demand also exposed a serving constraint. Hou reports 16 nights of PagerDuty wakeups in roughly 90 days because demand exceeded capacity. He describes the company as one of Anthropic’s and OpenAI’s largest consumers. An agent that contributes more work on the developer’s behalf also creates a larger operational burden for the product serving it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Observe and act in the same environment
Terminal activity supplies intent too. If a developer runs npm install or pip install, the agent should recognize the newly installed package and use the surrounding codebase context to infer how to integrate it. The developer should not have to copy the command back into chat. Hou extends this no-copy-paste ambition to documents and websites, while rejecting the idea that the terminal itself must become the whole future interface.
Observation alone is insufficient if execution happens somewhere else. Hou describes agent commands as running inside a sandbox, but places their interaction in the same terminal environment the developer uses, rather than an unrelated background shell script. The important property in the example is environment consistency: whether the human or Cascade installs a Python dependency, it should affect the environment in which the project runs. The presentation does not define the sandbox’s isolation boundaries.
Once the agent can follow an activity trajectory, continuation can become anticipation. Developers remain central to this vision, but the agent looks farther ahead: Hou imagines moving from a few steps of prediction to tens of steps. His future examples are writing unit tests before a function definition is finished and performing a codebase-wide refactor after a variable rename. These are extensions of the shared-timeline idea, beyond the continuation demo just shown.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Remember what the current task cannot tell you
A trajectory explains the immediate task, but not everything a senior engineer knows about a project. Organizational conventions, architectural decisions, and personal preferences accumulate over time. A capable general-purpose model has not necessarily had that exposure. Windsurf’s second principle, meta-learning, addresses the gap by retaining context about the developer and their organization.
The product combines several distinct mechanisms:
- Memories: A memory bank retains facts such as using Tailwind 4 or React 19 rather than React 18. Hou describes the ambition as telling the agent once and having it remember indefinitely.
- Tool integration: Custom MCP servers connect the agent to preferred tools and workflows.
- Command policies: Allow and deny lists express execution preferences, such as requiring approval before any
rmcommand.
Together, these mechanisms reduce repeated prompting. The longer-term aim is an assistant whose behavior reflects accumulated context, rather than requiring the developer to restate that context for each task.
The memory demo goes beyond an explicit instruction to remember something. A question about what the project does prompts Cascade to inspect files and routes. It then stores an understanding of the architecture and available endpoints for later messages and future conversations. Hou describes this as enabling subsequent work in a single prompt. Documentation lookup follows the same pattern: package versions found in package.json, or supplied by the user, guide searches for matching documentation.
That leads to the distinction between explicit context and inferred context. Windsurf supports rules files, but Hou views manually maintaining them as a temporary burden. Hou predicts that by the end of 2025, 99% of rules-file content will be inferred from the codebase or product usage. This is a forecast about personalization, not a demonstrated result: the envisioned system adapts across companies and developer skill levels without repeatedly asking for the same instructions. The presentation describes the early-2025 product; later documentation linked with the recording concerns legacy Cascade in Devin Desktop and should not be read as the same product snapshot.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Let better models remove interaction costs
The third principle is to scale with intelligence. Once an agent understands the current activity and retains longer-lived context, its architecture should let improved models turn those inputs into better work. That requires planning beyond the current release—to the next several months and years—even while new models and techniques arrive frequently.
The early excitement around ChatGPT’s November 2022 launch quickly encountered limits in what models could reliably accomplish. Teams compensated with embedding indices, retrieval heuristics, and output-validation systems. Hou’s criticism is of designing around a fixed level of intelligence: infrastructure that patches a model’s weaknesses can become a constraint if it prevents the product from benefiting when those weaknesses diminish. This is not a proposal to remove all retrieval or validation; Windsurf’s later examples still rely on retrieval.
One product consequence was replacing legacy chat with Cascade. The user still interacts through a conversational surface, but the system behind it is an agent that can plan and act. Hou suggests users might experience improved answers without noticing that the underlying chat implementation had been replaced.
Context selection provides a more specific example. Explicit @mentions helped users compensate when systems were poor at discovering relevant code and documents. As those capabilities improved, retrieval and agent planning could reconstruct more of the needed context automatically. Hou claims explicit @mentions are unnecessary 90% of the time, without supplying an evaluation method. @file and @web remain useful for directing the agent at the margin; the objective is to stop making that direction a prerequisite for ordinary work.
Consider adding Supabase to a Next.js application. Instead of supplying a chain of @web, @docs, and @codebase references, the developer asks the agent to add Supabase. The agent infers that it needs research, searches the web, and chooses what to read.
| Research decision | Model-directed behavior |
|---|---|
| Which results matter? | Select search results for the task. |
| Which content matters? | Read relevant portions of pages. |
| What comes next? | Use the gathered context to answer. |
Hou contrasts this with hard-coded research rules and a hypothetical embedding index whose results he expects would be worse; he does not present a measured comparison. The mechanism that matters is delegating research decisions to the model, so improvements in its judgment can improve the workflow. He projects the same direction toward more unsupervised work, full pull requests, and complex documentation reading.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From suggesting code to doing more of the work
The closing vision places Windsurf’s underlying engine at the center: infer conventions rather than requiring rules files, and generate commits and pull requests rather than stopping at isolated edits. Hou presents these as directions for 2025.
Hou reports that Cascade generates 90% of the code its users write, compared with approximately 20–30% for autocomplete. His spoken correction matters: the claim concerns the share of code, not the share of users. The closing slide says “over 90%.” Neither the cohort, observation window, denominator, nor acceptance criteria are supplied, so the figures describe his reported shift in code generation rather than a measured gain in productivity or correctness.
That shift changes the engineering problem. When an agent contributes a larger portion of the work, the developer needs a tool that can participate in the development process, not merely suggest its next fragment. Hou closes by encouraging developers to use agents, then points to an on-screen download QR code and a free tier available at the time of the presentation.
Suggest correction
Resources
Further reading
Kevin Hou's launch account explains Cascade's intent inference and the Continue my work interaction.
Updates since the talk
Current legacy-Cascade guidance on automatic memories, workspace scope and durable rules in Devin Desktop.
Documents terminal integration, execution approval levels and command allow/deny lists.
Explains automatic web search, explicit context mentions and selective reading of web pages.
Configuration instructions for connecting custom tools and services to legacy Cascade through MCP.
Read the complete timestamped transcript
- 0:00
[upbeat music] All right, how we doing, New York? [clapping]
- 0:18
Yeah. So my name is Kevin. This is our first ever Windsurf presentation, so you could say it's the first time we're kinda spilling the beans on, uh, what the IDE is all about.
- 0:30
So thank you all for coming. I'm gonna be talking about Windsurf, the first AI agent-powered editor.
- 0:38
So my name is Kevin Hou. I lead our product engineering team. We're a team based out of, uh, San Francisco. And thank you so much to Swix and Ben and the whole AI Engineering Summit team for inviting us here and letting us speak to you all.
- 0:51
Um, it's been a pleasure talking to people in the audience, uh, at the booth and just generally talking about AI. Uh, so let's dive into it. Windsurf is an agentic editor, and we're gonna talk a little bit about some of the principles that we use when we're building a product like this.
- 1:08
So we believe that agents are the future of software development, and you all are here, so you kind of understand the power of what agents can do, both for software engineering and otherwise.
- 1:17
Um, but to start, I'm gonna take you down a trip down memory lane, right? Let's go back to 2022. Copilot was the state-of-the-art. It just came out of beta.
- 1:26
People were experiencing the ghost text. They were seeing their completions, and it was one of the first times that people really got to see the magic of what AI could do for developers.
- 1:34
It was making them more productive, and we, Codeium, uh, decided we were gonna be one of the first companies to also launch an autocomplete product. So we garnered a couple million users on our VS Code, JetBrains, Vim, Emacs extensions.
- 1:46
Um, raise your hand if you were one of those Codeium users. Nice. Nice. Um, but we always knew that intelligence was gonna get better, right? Back then, we were doing short completions, maybe finishing your functions, but we knew that there were gonna be better models, larger models, better training paradigms, completely new, you know, RL, new tool use,
- 2:07
all this stuff. And so we knew that we wanted to build the best experience for devs possible. So even back then, we started looking at agents. We started thinking about, what could the future of software development be if models just got bigger?
- 2:19
And so we built the best experience that we could at the time, and that was a chat autocomplete product. But we always knew that copy-pasting from ChatGPT was gonna be a thing of the past.
- 2:29
We also knew that people were gonna probably tab less. We were gonna have LLMs that we'd be able to generate more and more. And who knows? You know, we always think our agents are the best now, but as a company, we're always thinking about the future.
- 2:41
We're technology optimists. So if an IDE in the future, who knows? We might not even be writing code inside of IDE-- of inside of IDEs. We'll just be there building the best product for SWEs.
- 2:51
And so this year, 2025, is finally the year where I feel like we are all recognizing the power of agents inside of software development. Agents are here to stay, and Windsurf, I'm proud to say, is pushing the envelope of that technology.
- 3:03
And we're gonna talk about some of those features, um, and we're gonna keep pushing that agentic future, um, because we believe that, you know, agents are going to move software engineering in a direction that no other LLM has done in the past.
- 3:17
So this slide, I guess, is titled vibe coding with Windsurf or also just coding in Windsurf. Um, so I'm gonna give you a quick demo about... This is the Windsurf product.
- 3:28
Here you have a, a sidebar. This is our agent. And you can see that we're going to be building a Python web scraper. So what this is gonna do, it's gonna build a Python web crawler, give us some stats about the website.
- 3:40
Um, and you can see it's actually installing dependencies from pip. Um, it's doing so inside of the terminal that you use, so you can interact with it. Um, it's suggesting edits, setting up your virtual environment, and we give a user a very helpful accept and reject so that you can go through and have confidence that the code
- 3:57
that it's generating works for you and your code base. Um, this is-- Of course, there's a lot more features under the hood. Um, some of the things that our users like to do, they like to look up documentation.
- 4:06
We have web search enabled by default. Um, it always looks at your code base, so you can graph through your code base. Uh, we can generate commit messages. You can drag and drop images, right?
- 4:14
The possibilities are truly endless. And I'm gonna be talking about
- 4:19
these features are powered by a handful of principles, a handful of through lines that we as an engineering team hold true as we're building. And as a team, we always go back to the same mission, which is to keep you in the flow
- 4:32
and unlock your limitless potential, right? We want to work on-- We wanna handle the grunt work for you. We wanna handle looking at your debug stack traces. We wanna handle modifying your original source code.
- 4:42
We wanna pull the correct version of documentation so that you never have to worry about pulling in the correct context. These are problems that we are trying to solve, um, and we want you to spend time on things that you are good at, right?
- 4:52
The things that make us all excited, which is shipping products, building great features, um, and generally just shipping code.
- 4:59
And so with that goal in mind, how do we tell what to work on? Um, it's a game of input and output. So we wanna allow users to give the least amount of explicit input possible to produce the most correct and production ready code, right?
- 5:15
We want you to contribute less, and we want our agent to contribute more. And we do this by reducing the amount of human in the loop required by doing things like background research.
- 5:26
We are always trying to predict your next step, and we'll make decisions on your behalf so that you can move faster.
- 5:32
And this might all seem like a fantasy, but Windsurf launched three months ago on November thirteenth. Um, that date is forever branded in my memory. Um, and these are the results that we're already seeing.
- 5:42
So in three months, we've been generating four point five billion lines of code. That is an absurd number. And since the time I started this presentation, we've actually probably sent-- users have probably sent thousands of messages to Cascade asking it to refactor code, to write new features, to build new pages on their website, um, to-
- 6:01
And also a fun statistic, since we're all engineers here, uh, we've had sixteen nights in the last, you know, ninety days where we've been woken up in the middle of the night from PagerDuty on-call because we've had some reliability issues, um, due to us exceeding our capacity, right?
- 6:14
These problems, these-- We've had immense success getting people onto the platform, um, and we've been very fortunate to have, uh, the issue of being some of Anthropic and OpenAI's largest, uh, consumers.
- 6:26
And so with these mission-- th-this mission and metric in mind, let's walk through some of the principles that we use when we're building this agentic editor. And for those of you that have used Windsurf, um, you might learn about some of the new ways that you could use the product.
- 6:38
And also for my own curiosity, how many of you have heard of Windsurf? Just so I know who we're talking about. Oh, let's go. [laughing]
- 6:45
That's sick. Um, how many of you use Windsurf?
- 6:49
Okay, everyone who put their hand down, door's over there. [laughing] Um, all right, let's get into it. So the first principle: trajectories. What is a trajectory? We use trajectories to read your mind.
- 7:01
So unlike editor-- other editors like Cursor, the elephant in the room, our agent is deeply integrated into the editor. And we'll talk about what exactly that means. But on one half, you can imagine an agent has to understand what you're doing.
- 7:14
And then on the other half, it either has to understand and be able to execute things on your behalf. And this has led to features like one of my favorites, quote, Continue my work.
- 7:24
So we are building up an understanding of the user as you're writing code, as you're executing terminal commands, and then you can actually just go into the, the agent sidebar and just say, "Continue my work," and it'll actually continue executing that, and it might even give you a full PR or a full commit, right?
- 7:38
We also have things like terminal execution mode, right? It can automatically use the LLM to decide what is safe and not safe, so that if you're running something like Git, it'll just work.
- 7:48
Or if you-- it'll probably prompt you if there's an RMRF somewhere. You probably don't wanna run that automatically, and the LLM will be like, "Oh, we should probably flag to the user to confirm this."
- 7:56
These are just some of the ways that we try and let the human be in the loop, but as minimal as possible. And then finally, we also have, you know, a, a stellar UX, a stellar design team that's been working on how to integrate these sort of cutting-edge features into a product in a way that allows the
- 8:10
user to feel like they're in control, to be able to accept and reject changes into their code, so they can have confidence in the code that they're pushing to production.
- 8:18
So here is how a trajectory works. Um, we have this notion of a unified timeline. So an agent is working in the background behind the scenes to understand what the user is implicitly doing.
- 8:30
So this includes things like viewing files, navigating around your code base. Um, let's say you edit a file, uh, and then the agent will edit a file. This all kind of goes into a shared timeline of actions.
- 8:42
You can imagine this includes things like searching, grepping, um, making edits, making commits, right? The user has this sort of holistic understanding of what you're doing.
- 8:51
And this entire experience is unified by this shared timeline. So you can contribute to it, it can contribute to it, and in this way, you never run into the problem where you're talking to the agent and it undoes the change that you just did or has some, you know, outdated notion of what the file state is.
- 9:08
So this is a first-class principle of ours, and when we decided we were gonna build an editor, we were going to build it around this notion of an agent in a shared timeline.
- 9:17
And so here's an example of this feature in action. Here, we're adding a new function, and you're seeing the autocomplete and all the kind of, like, bells and whistles of that feature.
- 9:25
And in the right side, we just ask, Continue my work. This is a new function. We probably want our form handler to use this new function. And you can see based on the context that we gave it by making edits, it's guessing.
- 9:36
Okay, we probably wanna make this file change to this file, maybe some others. And at the end, it's actually just saying, "Okay, let's just run npm run dev." And it can run terminal commands on your behalf in the background in your kind of like command J terminal pop-up.
- 9:50
Um, and in this way, we're keeping you in the flow, right? Something that would have taken minutes is now taking seconds.
- 9:56
And here's another example. Uh, the terminal is now deeply integrated into the agentic timeline. So here, if you're typing commands, you know, the classic example is like I npm install a new package, or I pip install a new package.
- 10:07
The agent should know, "Oh, you just installed this package. Why don't we go ahead and implement it into your project?" And based on context that it's able to pick up around the code base, it can continue that line of work.
- 10:17
So we very strongly believe in a future of no copy-paste, right? You should never have a situation where you're in a terminal, or you're in a document, or even on a website, and you're copy-pasting text into an agent.
- 10:29
That's just not how the way the world works. And in the same way, we strongly believe the future is not going to be at terminal.
- 10:38
Here's another example of commands running inside of your terminal. I've been talking about this for a little bit. And this concept of a trajectory allows us to automatically execute things inside of a sandbox that is as similar to the way you run commands as possible.
- 10:50
So instead of running some shell script in the background, what we do is we put this right inside of the place that you would actually write terminal commands. So if you pip install something or it pip installs something, it's going to the same environment.
- 11:01
You'll never have this instance of kind of weirdness. And, and this is all part of our effort to bring these two sides, the agentic side and the human side, close together, as close together as possible, and you do this through building a unified product.
- 11:15
We believe that developers are here to stay, and if you wanna work seamlessly with a developer, that means the agent has to understand what they are thinking. Windsurf has to be ubiquitous, and the agent will be reading more and more of your mind, doing things that you might not even know it's doing.
- 11:31
In the future, we'll be looking not just one to five steps in the future, but ten, twenty, thirty steps into the future. It'll be writing unit tests before you've even finished defining the function.
- 11:40
It'll be performing code-based wide refactors on multiple files based on you just simply editing a variable name. All this is part of this unified trajectory concept.
- 11:49
Now, the second principle is meta-learning. So even if Windsurf understands what you're doing in the moment, there is still an inferred understanding of your code base and your preferences and your organizational guidelines that, let's just say, senior engineers at your company have built up a notion of over time.
- 12:07
We call this concept meta-learning. So Windsurf we've built from the ground up to bu- to adapt and remember these things about you and your company. So if you think about a frontier LLM, right?
- 12:19
The best LLMs that they exist in the world, they're very, very smart engineers, definitely more capable than, than I, probably more [chuckles] capable than most of you. They can just write an enormous amount of code and do so correctly, and it probably runs and compiles pretty well.
- 12:33
But what they do not have is the exposure that you've had, the education that you've had, and the ability to kind of remember and, and know how you personally or your company writes code.
- 12:43
And so what does this mean for our product? We've implemented a concept called auto-generated memories. So over time, we build up a memory bank, what you are doing. So you can say, remember that I use Tailwind version four, or remember that I use React 19 instead of 18, and these things will be remembered.
- 12:58
You say 'em once, and they'll be remembered forever. We also allow people to implement things like custom MCP servers, so you can plug in your favorite tools, we can adapt to your workflow.
- 13:07
We will also allow you to whitelist and blacklist commands. Going back to that same concept, we wanna keep you in the flow as least-- or sorry, we wanna keep you in the flow as much as possible, but we can tell the agent, "Hey, never run an RM command without my approval."
- 13:20
And so in this way, it learns about your preferences over time.
- 13:24
And if you think about what makes a developer effective, it's because they remember things that you tell them. And Windsurf must also model this behavior if we hope that AI should write and maintain projects for us.
- 13:36
So in the short term, this means you don't need to prompt the agent again and again to do the same thing over and over, um, but in the long term, the AI should just feel like a seamless extension of yourself.
- 13:46
It's this idea of explicit versus inferred context.
- 13:51
And we always have the saying at the company, ideas are cheap. So here's an example of auto-generated memories in action. Here, we're not even explicitly telling it, remember this thing.
- 13:59
We're just giving it an architecture overview. We're asking, what does this project do? And it's remembering based on a couple tool uses. It's looking at a couple different files, looking at the routes, and now it's committed to memory, hey, this is the project that this person is working on.
- 14:11
Here are the endpoints that are available, and we can reference that in the next message that we send, right? So in the n- future conversation, we can now one-shot things because we have a notion of a memory bank.
- 14:21
In the same way, documentation is auto-learned. We know what packages you're using because of your package JSON, because you've explicitly told us, and we're able to look up the web, look on the web for documentation that matches those versions, and we do so all implicitly.
- 14:37
And so the dream of meta-learning is that you can have an entirely inferred sense of context based on a code base or based on the usage of the product.
- 14:47
And auto-generated memories are a step in that direction. Um, we strongly believe that having a rules file, you know, we do allow users to, to add a rules file.
- 14:56
We strongly believe that a rules file is a crutch. You know, by the end of twenty twenty-five, ninety-nine percent of the things that you're gonna put in a rules file will be interpreted or inferred based on your code base or your usage.
- 15:07
So our dream is that every single Windsurf instance, every single user using Windsurf, regardless of the company or the type of person, the skill of the developer, will be personalized to that user, and you only have to tell it one thing.
- 15:20
And finally, my favorite principle, which is scale with intelligence. So what does this mean? Now that Windsurf understands what you're doing in the moment, right, the first principle, and can improve over time, the second principle, how do we actually build an agent that will scale with the rates at which LLMs are scaling?
- 15:36
And while we're trying to ge- always give you the best tool today, we recognize that new models are coming out every other week, right? Every day, there's some new article about some new pattern, and it's really, really hard to keep up.
- 15:47
But we always think at Codeium, how do we stay on top of this? How do we build the best product for not just today, but three months, six months, twelve months out, three years from now?
- 15:56
So in twenty twenty-one, when ChatGPT came out, you probably like me, we all had our imaginations running wild. We were like, okay, we're gonna solve, you know, AGI, post-economy, whatever.
- 16:06
But obviously, there's a lot of things that need to happen between then and that future. And so models at that time were, quite frankly, a little bit too, too dumb to be able to compl- accomplish everything that we wanted them to do.
- 16:18
So we built up a lot of infrastructure, and you and I have all probably done this. We build out embedding indices, we build retrieval heuristics, we have output validating systems to make sure that the code that it's generating is good, right?
- 16:28
These are all things that we're able to help at the margin. But this is all predicated on the assumption that we're operating with a fixed notion of intelligence. Twenty twenty-one, twenty twenty-two, these models we were operating, we were building all this infrastructure to compensate for areas and edge cases that models could not handle.
- 16:46
And what's very different about the way we're approaching Windsurf is that we want our product to scale with the models. So if the models get better, our product gets better.
- 16:55
And I'll give you one such example. Um, it kind of surprised me. I was, you know, when I landed in New York, I tweeted that we deleted chat in Cascade.
- 17:02
I was like a very, uh, I don't know, I was just-- I had thoughts. [chuckles] And weirdly, a lot of you picked this up, and this is an example of something that we feel very strongly about.
- 17:13
One example of this principle in practice is that we deleted chat. So what does this mean? We only have an agent, and it's called Cascade inside of Windsurf. Chat is a legacy paradigm, and we completely replaced it, and as you can see here, users are enjoying it.
- 17:27
Or in fact, they might not even know the difference, but they're just enjoying the higher quality.
- 17:32
An example of this is [REDACTED:username]. We built [REDACTED:username], and probably you all have used [REDACTED:username] because context was not very good a year or two years ago. Today, Windsurf can dynamically infer the relationships between bits of code and documents.
- 17:45
Ninety percent of the time, you do not need to @mention something. All you need to do is let the retrieval system and the agent kinda plan out what it needs to do and then reconstruct the context automatically for you.
- 17:57
So [REDACTED:username] and [REDACTED:username], these are very helpful patterns when you're working at kind of the margin, but these are eventually eking out basis points. In the long term, we believe that LLMs are going to improve, and they already have improved to the point where you don't need to explicitly specify an @mention.
- 18:12
The LLM should be intelligent enough to pick it up. And so in this example, previously, I was implementing Supabase inside of a Next.js app. Previously, you'd be [REDACTED:username], you'd be [REDACTED:username], [REDACTED:username], [REDACTED:username], [REDACTED:username].
- 18:24
No, just [REDACTED:username], right? And it's able to infer and plan out, let's search the web. Let's behave like a human would. And to get into this, there's, there's also web search built into, um, Windsurf, and what's very special about this is that it reads the web the way a human would read the web.
- 18:40
So instead of these hard-coded rules, and, you know, we probably could have created an embedding index, but we would probably get very low quality results. And so instead, we said the LLMs are very, very good.
- 18:50
Let's let the model decide what it wants to do. Let's have it decide which search results to read, what parts of the page to read, and then finally, give us an answer.
- 18:59
And so we believe that as models will continue to get better, we're gonna be cu- continuing to do unsupervised work. We're gonna generate full PRs, we're gonna read complex documentation.
- 19:07
The possibilities are truly endless. And so here are some of the principles that we just talked about.
- 19:14
Um, where are we going with this? There's a lot of ways we can take this, right? The engine underneath Windsurf is really, really the secret sauce.
- 19:21
And we believe that we're gonna be-- 2025 is gonna be a whole new world. No rules files, generating PRs, generating commits. It's gonna be crazy.
- 19:30
And we're already seeing this. Ninety percent of our users... Or sorry, all of our users, ninety percent of the code that they're writing is generated with Cascade. That's an astonishing number.
- 19:39
Autocomplete was more in, like, the twenty, thirty percent. This is insane, right? Your people are using agents today to accomplish so much more than they could have in the past.
- 19:48
And we're all software engineers. I wanna make sure that every single person in this room is armed with the best tools, and those best tools are agents.
- 19:56
And like every good thing in the city, [laughing]
- 20:01
I expect tips. Twenty-five percent of your ticket price, which I heard was quite a lot. Um, here's the actual QR that you're probably curious about. Um, this is Windsurf's download link.
- 20:11
We offer a free tier. Um, so go ahead and, and scan that. Start using the magic today.
- 20:18
And then finally, we have some killer swag at our booth. Um, you can also connect with me on Twitter. I try and stay active with the community. But thank you so much for watching.
- 20:26
I hope that you all learned something about how we're building at Windsurf, and enjoy the rest of the conference. [upbeat music]