Mastering Engineering Flow with Windsurf

[on hold music] Hey everyone, um, I'm Eashan.

I'm an engineer here at Windsurf, and today we'll be talking a little bit about, um, how to make the most out of your development experience, how to make the most out of this agentic flow that we all now have exposure to with our IDEs.

Um, and also talk a little bit about how these flows make us, um, better developers.

For those who are not aware, Windsurf is in the dev tool space. Our flagship product is the Windsurf Editor, um, which is, uh... Oh, as you can see.

Okay. Sorry, give me one... Will it not share if I... Okay. Um,

all right. Our flagship product is the Windsurf Editor, which is powered by our agent Cascade, um, which, uh, was actually the first agentic IDE in the space. After we launched a lot of tools, a lot of similar products followed suit in that they realized that this agent, uh, experience was the way to go, um, with this, um,

with this IDE. Um, so for those who aren't aware or haven't tried it out, highly suggest you try it out. But before we actually get into how Windsurf does agents, how we do flows, um, let's take a step back.

Let's talk about some of the most iconic duos, um, till date, uh, and, and those that have really, um, won, that have been successful. Um,

what are some of the characteristics of, of these duos, and what has really led them to be so successful? It wasn't that each individual or each one of these were the best at their position or they were the best by far or considered the GOAT, um, although some may argue otherwise for some of these people.

Um, what made them so good was that together as a team, they worked better than everybody else, and that's what led to success. Um,

one of the most iconic duos, pineapple and pizza, uh, regardless of what you all say. Um, this is what makes duos successful, is that they work together and they know each other.

They complement each other very well. Another one of the most iconic duos. What this reminds me of is how we think of our agents or how we think of our coding assistants.

Um, a lot of times we fight with them. We, uh, we ask ourselves, like, why is it not getting us? Why is it producing all this error- error-prone code?

Why is it duplicating code? Why is it removing code that we don't want it to remove? Um, we also tend to abuse our agents sometimes. We, uh, we tell it that we're gonna fine it one million dollars if it doesn't do what we ask it to do.

We also tell it that it's gonna go to jail if it doesn't do what we want it to do. But that's not how it's supposed to be. We are supposed to treat our agents like we would treat our, uh, running mate, our teammate, our friend, and this is what it's supposed to look like, right?

Not like what Tom and Jerry are. So, um, it's not your fault as developers, it's ours. It's ours as the builders of these tools to provide that experience for you, to make sure that you as developers, um, you're actually able to work with these agents, that these agents understand you.

Um, how do we fix this problem? How does Windsurf approach this?

Before I dive in depth into that, let's, let's take a step back and look at, um, how we've gotten to this point of agents, uh, the evolution of AI, how AI has kind of evolved into what we see today with these coding agents.

Back in twenty twenty-two, the ancient times, um, we had to do everything ourselves, right? It's, it's kind of terrifying. We had to write all the code by ourselves. There was no AI to really help us, right?

There was just Stack Overflow, um, and Google.

In twenty twenty-two or late twenty twenty-two and moving on to twenty twenty-three, uh, copilots were introduced. I consider ChatGPT, uh, Bard at the time, um, GitHub Copilot as this kind of chat interface, this copilot kind of, uh, experience where you would give a prompt or an input, you'd get a response.

Really good with simple Q&A and autocomplete. Late twenty twenty-four, this is when, uh, we saw the first agents or what people like to call agents. Um, a lot of times people would confuse, uh, confuse agents with workflows, but I think that was kind of cleared up, uh, more recently in that agents now are able to take this

autonomy, they take this independence, they operate, um, iteratively, they adjust their trajectories, and they can perform these larger scope tasks and, um, do things that simple or single, uh, response, single shot copilots would not be able to do.

So another way to look at this is that copilots were a little bit more collaborative, right? We had to interact at every single step of the process while we're working with copilots.

If we ever were coding with ChatGPT, we'd have to maybe paste in every file, we would have to, um, individually send in each response, and ChatGPT would have to work on things very step-by-step, right?

So we would just send an input or a prompt, maybe add some extra context, and after the LLM ran its inference, we would get the response. Agents then introduced this autonomous nature where we got-- had, had these models, um, we also allowed it to retrieve this context.

But on top of that, we introduced tool calling and function calling, the ability for agents to perform tasks, um, perform these functions, and actually be able to execute things that copilots or chatbots wouldn't necessarily be able to do.

What Windsurf has done when we launched was we realized that agents really didn't solve the problems that, um, copilots couldn't solve, and copilots didn't do everything that we would want to do as developers as well.

And so we took the best of both worlds in that we combined

We combined, uh, these models as well as retrieving proper context, uh, figuring out how to, uh, call tools properly, in addition with understanding the user, tracking the user's actions, really, uh, understanding their intent as developers, what they're going to do.

So we essentially took the best of both worlds, right? Um, and so AI Flows is what Windsurf and Cascade introduced back in November, and this is where a lot of other companies, a lot of other products that I'm sure you all know today followed suit in that they realized this simple chat interface or even having an agent

and a chat just maybe didn't make sense. It only made sense to provide one singular agentic interface that collaborated with you as a developer. And so Windsurf, our editor, it took the best of both worlds in that it combined this collaborative power of a chatbot interface with some of these autonomous and tool calling capabilities of an agent

and molded them together to work in perfect unison, in perfect sync. And this created a very seamless, um, a very unified experience where developers and AI could actually operate as one, could operate as a team rather than like these guys.

So how did Windsurf do this? The first thing we wanted to consider was this concept of flow awareness. What this meant was that we would have really comprehensive, uh, reasoning and understanding of the implicit user intent.

This is something that a lot of agents actually don't really consider right now, and, um, you know, even when we're building this on the side, we don't actually think of what is really important to the user.

So our main emphasis when we were building Cascade was understanding the user, tracking their actions, their edits, their commands, the terminal commands they've run, um, their, uh, anything that's in their clipboard, um, all the files that they've recently edited.

All these things are tracked by Cascade so that Cascade develops an understanding of what the user has been doing, and that is all inputted into this agent's trajectory so that the agent can then outline a much more, uh, relevant set of steps that aligns with what the user would be doing or what may be doing in the

future. And so when you use Cascade, when you use Windsurf Tab, it almost feels like Windsurf is predicting your, your next step. It's, it's, uh, you know, it's almost like an LLM.

It predicts the next token. In this case, Cascade is, is predicting or inferring what you would do next. When you're using Tab, it feels like Cascade or Windsurf is reading your mind because so much of this context of the user's, um, actions as well as, like, this, uh, understanding of the user over time as the user interacts

with Cascade, this is inputted into the context window. And this is what makes this agent so powerful, is that it understands the user much better than a very general purpose or independent agent.

On top of that, we have a state-of-the-art context engine. We have a talk on this tomorrow as well. But, uh, we approach context differently than other products in this space.

We don't just use a RAG or embedding-based search approach. We leverage a combination of multiple tools, um, in tandem to really figure out what works best so that we can understand your codebase, this explicit context, as strong and comprehensively as possible.

And what this, what this helps us do is, as an agent, is it helps us get more accurate results, more relevant suggestions, right, for your codebase, um, or for any of these code suggestions, right?

We have reduced hallucinations. We don't have to do any guesswork. Because we understand the user, because we understand your codebase very well, we are able to provide a much more tailored experience, an experience that actually outlines of what the user may want, and, um, it's grounded in this centralized, uh, source of truth, which is this codebase that

you're working in. On top of that, we equip Cascade with all of the best tools for this agent to really perform that multi-step, iterative, uh, kind of set of tasks where it's not just limited to that single response, um, nature.

It can actually call MCP servers. It can leverage workflows, something we recently introduced, where now we are bringing together, bridging that gap between the unpredictability of an agent and more of that deterministic nature of a workflow, right?

Where workflows, we know exactly what's gonna happen and when it's gonna happen. And so with Windsurf, again, our main priority is to help developers as much as possible. We realize that with agents, it's very unpredictable what's gonna happen and what they're gonna do.

And so with workflows now, this bridges that gap. We can actually, as users, define a set of steps for the agent to follow as they're operating. On top of that, we allow Cascade to look at rules, right?

These are rules that you can generate as users. Um, they could be file-based rules. They can be rules that, um, you always want the model to look at, you, uh, maybe sometimes want the model to look at.

On top of that, Cascade can generate memories of you as a user, some of your preferences, memories of your codebase so that it doesn't have to constantly index, doesn't have to constantly retrieve your codebase.

And on top of that, recently, there's a lot of talk about ATA, A2A, and, like, multiple agents. Um, recently, we introduced multiple simultaneous Cascades working in tandem. And so what this brings to us is it allows Cascade now to have these multiple different, um, you know, trajectories that understand each other, understand the user, and understand your codebase,

which allows us to be able to complete tasks faster, more efficiently, and get things done, um, you know, in the way that we want to get them done. So all these tools, right, uh, there's a lot that I left out here, like the ability to search the web and other things like that.

They empower Cascade to be able to really give us this agentic feeling while it's operating, right? And really, not just, again, an independent agent, but one that understands us as users.

Um, but as engineers, how do we make the most, how do we get the most out of these flows?

Uh, also known as eng- engineer maxing. How do we really max out what we get out of the, this experience? Uh, the way I like to approach it, I'm sure you all are somewhat familiar with this kind of set of steps.

We like to first explore, um, discover our codebase, scope out our tasks, then plan, um, then build, and then test out, uh, our, our changes or anything that the agent did.

Um, when discovering, we can leverage Cascade at every set, um, of these steps, right? We want to leverage Cascade to understand our codebase, to scope out our tasks, determine this definition of done, right?

That's what a agent does, right? It determines the definition of done and outlines a set of steps. How can we tell Cascade what that definition of done is and talk through some of these goals?

On top of that, if we wanted to give more direct context, we can @mention, um, different files and directories. Um, it's also very important to plan with Cascade, right?

A lot of people just say, "Hey, I'm just gonna put in this prompt and let Cascade or let this agent just build everything for me." The best way to go about this is create, work with the agent to understand you.

And so what that means is, um, create a planning file. Outline like, you know, a set of tasks with like maybe checkboxes to tell Cascade, "Hey, you need to hit these set of tasks to accomplish this definition of done."

Also, outline rules to tell Cascade how to behave that align with your preferences.

And then we go into building. Work with Cascade to actually execute this plan that you've set for yourself. Um, edit files one by one or multiple files at a time, and ensure Cascade is working with this planning document, um, and actually checking all the boxes.

And you'll see that Cascade actually asks you questions. It will check in with you as a user, as a developer, right? And you, like, make sure to answer it very clearly.

Tell it, "Hey, you're doing this incorrectly," or, "Hey, uh, let's actually look at this first," or, "Let's look at, um, this ne- set of steps next," right? Um, Windsurf Tab then provides this more hands-on experience with autocomplete.

And on top of that, you can leverage these simultaneous Cascades and these different MCP servers that allow you to pull additional context and empower Cascade with these additional tools to complete, uh, you know, this agentic experience.

Lastly, then you wanna generate tests with Cascade, right? Um, generate, run, uh, fix your tests one by one as it's iterating. You can leverage workflows here, which, uh, you know, can, you can leverage to automate some of these tasks.

And, um, at the end, determine if Cascade hit that DoD, that definition of done. If it didn't, make sure Cascade understands what it did wrong 'cause Cascade is building this learning of you.

It's building this embedding representation of you as a developer, um, and it's learning from that. So in the future, it knows where to not go wrong and where to improve.

Um, and then lastly, then you wanna commit to Git, uh, and, and make sure that you're pushing code that is functional.

So you and Cascade, right? Don't think of you guys as separate entities. We wanna think of you all as a merge, as a team, right? As a peer programmer, um, you guys are working together to accomplish tasks.

And so this is how you and Cascade should be. This is how developers and Cascade should be. It shouldn't be separate where you tell Cascade, "Hey, just accomplish these set of tasks.

I'll come back in 30 minutes, and, um, and we'll see what you did," right? We're not at that level where LLMs can do that just yet. And so really work with Cascade, make it your friend, and that is how you'll get the best, uh, development experience out of these agents. [audience applauds] [upbeat music]