How Windsurf writes 90% of your code with an Agentic IDE - Kevin Hou, Windsurf

Allright, how are we doing in New York?

Yeah.

So, my name is Kevin. This is our first ever Windsurf presentation, so you could say it's the first time we're kind of spilling the beans on what the IDE is all about. So thank you all for coming. I'm going to be talking about Windsurf, the first AI agent-powered editor.

So, my name is Kevin Hou. I lead our product engineering team. We're a team based out of 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.

It's been a pleasure talking to people in the audience at the booth and just generally talking about AI. So let's dive into it. Windsurf is an agentic editor, and we're going to talk a little bit about some of the principles that we use when we're building a product like this.

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. But to start, I'm going to 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. 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.

It was making them more productive. And we, Codeium, decided we were going to be one of the first companies to also launch an auto-complete product. So we garnered a couple million users on our VS Code, JetBrains, Vim, Emacs extensions.

Raise your hand if you were one of those Codeium users. Nice. Nice. But we always knew that intelligence was going to get better,right? Back then, we were doing short completions, maybe finishing your functions. But we knew that there were going to be better models, larger models, better training paradigms, completely new RL, new tool use, 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.

And so we built the best experience that we could at the time. And that was a chat auto-complete product. But we always knew that copy-pasting from ChatGPT was going to be a thing of the past. We also knew that people were going to probably tab less.

We were going to have LLMs that would be able to generate more and more. And who knows? We always think, allright, agents are the best now. But as a company, we're always thinking about the future. We're technology optimists.

So if an IDE in the future, who knows? We might not even be writing code inside of IDEs. We'll just be there building the best product for SWEs. 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. And we're going to talk about some of those features. And we're going to keep pushing that agentic future because we believe that agents are going to move software engineering in a direction that no other LLM has done in the past.

So this slide, I guess, is titled "Vibe Coding with Windsurf," or also just "Coding in Windsurf." So I'm going to give you a quick demo about this is the Windsurf product. Here, you have 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 going to do, it's going to build a Python web crawler, give us some stats about the website. And you can see it's actually installing dependencies from pip.

It's doing so inside of the terminal that you use, so you can interact with it. 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 that it's generating works for you and your code base.

This is, of course, there's a lot more features under the hood. Some of the things that our users like to do, they like to look up documentation. We have web search enabled by default. It always looks at your code base, so you can grep through your code base.

We can generate commit messages. You can drag and drop images,right? The possibilities are truly endless. And I'm going to be talking about 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 and unlock your limitless potential,right? We want to work on we want to handle the grunt work for you. We want to handle looking at your debug stack traces.

We want to handle modifying your original source code. We want to 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.

And we want you to spend time on things that you are good at,right? The things that make us all excited, which is shipping products, building great features, and generally just shipping code.

And so with that goal in mind, how do we tell what to work on? It's a game of input and output. So we want to allow users to give the least amount of explicit input possible to produce the most correct and production-ready code,right?

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. We are always trying to predict your next step, and we'll make decisions on your behalf so that you can move faster.

And this might all seem like a fantasy, but Windsurf launched three months ago, on November 13. That date is forever branded in my memory. And these are the results that we're already seeing. So in three months, we've been generating 4.5 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.

And also, a fun statistic, since we're all engineers here, we've had 16 nights in the last 90 days where we've been woken up in the middle of the night from PagerDuty on-call because we've had some reliability issues due to us exceeding our capacity,right?

These problems, these we've had immense success getting people onto the platform. And we've been very fortunate to have the issue of being some of Anthropic and OpenAI's largest consumers. And so with 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, you might learn about some of the new ways that you could use the product. 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. That's sick. How many of you use Windsurf? OK, everyone who put their hand down? Doors over there.

Allright, let's get into it. So the first principle, trajectories. What is a trajectory? We use trajectories to read your mind. So unlike 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. 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." 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 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? 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.

Or it'll probably prompt you if there's an RMRF somewhere. You probably don't want to run that automatically. And the LLM will be like, oh, we should probably flag to the user to confirm this. 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 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 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.

So here is how a trajectory works. 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. So this includes things like viewing files, navigating around your code base.

Let's say you edit a file, and then the agent will edit a file. This all kind of goes into a shared timeline of actions. And you can imagine this includes things like searching, greping, making edits, making commits,right? The user has this sort of holistic understanding of what you're doing.

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 outdated notion of what the file state is.

So this is a first-class principle of ours. And when we decided we were going to build an editor, we were going to build it around this notion of an agent and a shared timeline. And so here's an example of this feature in action.

Here, we're adding a new function. And you're seeing the auto-complete and all the kind of bells and whistles of that feature. And in theright 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, OK, we probably want to make this file change to this file, maybe some others. And then at the end, it's actually just saying, OK, let's just run npm run dev.

And it can run terminal commands on your behalf in the background in your kind of command J terminal pop-up. And in this way, we're keeping you in the flow,right? Something that would have taken minutes is now taking seconds.

And here's another example. The terminal is now deeply integrated into the agentic timeline. So here, if you're typing commands, the classic example is like, I npm install a new package, or I pip install a new package. 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. 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. 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.

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.

So instead of running some shell script in the background, what we do is we put thisright inside of the place that you would actually write terminal commands. So if you pip install something, or it pip install something, it's going to the same environment.

You'll never have this instance of kind of weirdness. 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.

We believe that developers are here to stay. And if you want to 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.

In the future, we'll be looking not just one to five steps in the future, but 10, 20, 30 steps into the future. It'll be writing unit tests before you've even finished defining the function. It'll be performing code base-wide refactors on multiple files based on you just simply editing a variable name.

All this is part of this unified trajectory concept. 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.

We call this concept meta-learning. So Windsurf, we've built from the ground up to adapt and remember these things about you and your company. So if you think about a frontier LLM,right, the best LLMs that exist in the world, they're very, very smart engineers.

Definitely more capable than I, probably more 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. 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 know how you personally or your company writes code.

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 of what you are doing. So you can say, remember that I used Tailwind version 4, or remember that I used React 19 instead of 18.

And these things will be remembered. You say them 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.

We will also allow you to whitelist and blacklist commands. Going back to that same concept, we want to keep you in the flow as least or, sorry, we want to keep you in the flow as much as possible.

But we can tell the agent, hey, never run an RM command without my approval. And so in this way, it learns about your preferences over time. 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. 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.

But in the long term, the AI should just feel like a seamless extension of yourself. It's this idea of explicit versus inferred context.

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, hey, remember this thing. We're just giving it an architecture overview. We're asking, what does this project do?

And it's remembering based on a couple of tool uses. It's looking at a couple of different files, looking at the routes. And now it's committed to memory, hey, this is the project that this person is working on. Here are the endpoints that are available.

And we can reference that in the next message that we send,right? So in the future conversation, we can now one-shot things because we have a notion of a memory bank. 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. 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.

And auto-generated memories are a step in that direction. We strongly believe that having a rules file, we do allow users to add a rules file. We strongly believe that a rules file is a crutch. By the end of 2025, 99% of the things that you're going to put in a rules file will be interpreted or inferred based on your code base or your usage.

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'll only have to tell it one thing.

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?

And while we're trying to 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.

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, 12 months out, three years from now? So in 2021, when ChatGPT came out, you probably, like me, we all had our imaginations running wild.

We were like, OK, we're going to solve AGI, post-economy, whatever. 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 dumb to be able to accomplish everything that we wanted them to do.

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?

These are all things that we're able to help at the margin. But this is all predicated on the assumption that we were operating with a fixed notion of intelligence. 2021, 2022, these models we were operating, we were building all this infrastructure to compensate for areas and edge cases that models could not handle.

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. And I'll give you one such example. It kind of surprised me.

When I landed in New York, I tweeted that we deleted chat in Cascade. I was like a very, I don't know. I had thoughts. And weirdly, a lot of you picked this up. And this is an example of something that we feel very strongly about.

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.

Or in fact, they might not even know the difference, but they're just enjoying the higher quality. An example of this is App Mentions. We built App Mentions. And probably you all have used App Mentions because context was not very good a year, two years ago.

Today, Windsurf can dynamically infer the relationships between bits of code and documents. 90% of the time, you do not need to App Mention something. All you need to do is let the retrieval system and the agent kind of plan out what it needs to do and then reconstruct the context automatically for you.

So At File and At Web, 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 App Mention.

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 At Webbing. You'd be At Docs, At Codebase, At This, At That.

No, just At Supabase,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 also web search built into Windsurf. And what's very special about this is that it reads the web the way a human would read the web.

So instead of these hard-coded rules, and 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. 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. And so we believe that as models will continue to get better, we're going to be continuing to do unsupervised work.

We're going to generate full PRs. We're going to read complex documentation. The possibilities are truly endless. And so here are some of the principles that we just talked about.

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. And we believe that we're going to be 2025 is going to be a whole new world.

No rules files, generating PRs, generating commits. It's going to be crazy. And we're already seeing this. 90% of our users or, sorry, all of our users, 90% of the code that they're writing is generated with Cascade. That's an astonishing number.

Autocomplete was more in like the 20%, 30%. This is insane,right? People are using agents today to accomplish so much more than they could have in the past. And we're all software engineers. I want to make sure that every single person in this room is armed with the best tools.

And those best tools are agents. And like every good thing in the city,

I expect tips. 25% of your ticket price, which I heard was quite a lot. Here's the actual QR that you're probably curious about. This is Windsurf's download link. We offer a free tier. So go ahead and scan that.

Start using the magic today.

And then finally, we have some killer swag at our booth. You can also connect with me on Twitter. I try and stay active with the community. But thank you so much for watching. I hope that you all learned something about how we're building at Windsurf and enjoy the rest of the conference.