# Mastering Engineering Flow with Windsurf

Eashan Sinha

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/W_5tzQY-hVs-mastering-engineering-flow-windsurf) · [Video](https://www.youtube.com/watch?v=W_5tzQY-hVs)

## Mastering Engineering Flow with Windsurf

Effective agentic development combines context, tool use, and active collaboration: discover the task, plan explicitly, build with feedback, and verify the result.

Familiarity with a code editor, automated tests, and Git is sufficient; no prior Windsurf experience is required.

### What makes a developer and an agent work well together?

[0:17](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=17s)

How do you get more out of an agentic IDE—and become a better developer while using it? That is the practical question Eashan Sinha, introducing himself as an engineer at Windsurf, brings to the Windsurf Editor. Its agent, **Cascade**, provides the setting for exploring how developers and AI can work together.

[Windsurf Editor](https://khou22.com/blog/2024-11-14-introducing-windsurf-editor) is powered by Cascade. Sinha describes it as the first agentic IDE and credits its launch with influencing competing products; those are his claims about the market. To explain the experience it aims to create, he starts with successful duos. The opening basketball photograph makes the point: a pair succeeds through how its members work together, not simply because each is individually the best.

![Basketball photograph showing Lakers players in yellow jerseys numbered 34 and 8, with the speaker inset at lower left.](https://ai.engineer/api/talk-essay-media/16cae36a185ab09d69b8e6a2d8630586b43b12bdcd5f474034d96bacfd0cd925)

A basketball duo introduces the theme of teamwork.

Then comes his more contentious pairing: pineapple and pizza. Whatever your taste, the analogy is about complementary parts that work well together. Coding assistants often feel like the opposite. They produce erroneous code, duplicate existing logic, or remove code the developer wanted to keep. The developer responds by fighting the assistant—or threatening it with a million-dollar fine or jail if it fails.

**A useful coding agent needs to behave like a teammate.** Sinha places responsibility for that experience on the people building the tools: developers should not have to struggle to make an agent understand what they are doing. The product must make cooperation possible.

### From single responses to collaborative execution

[3:30](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=210s)

Sinha sketches a progression from writing code with Google and Stack Overflow, through copilots in late 2022–2023, to agents in late 2024. This is a simplified account of changing interaction styles, not a literal history of when coding assistance began: AI coding assistance was already available during 2022. He groups ChatGPT, Bard, and GitHub Copilot under the copilot experience—give the system an input and receive a response, particularly useful for questions and autocomplete. Agents add independence: they can iterate, adjust their trajectory, and pursue larger tasks.

The practical difference becomes clear when working across files. In the chat-based copilot pattern, the developer pastes files, supplies context, and intervenes at each step. An agent can retrieve context itself and use tool or function calls to act on the environment.

| Interaction | Context | Execution |
|---|---|---|
| Prompt–response copilot | Developer supplies files and details | Returns a response; developer advances the work |
| Iterative agent | Retrieves relevant context | Calls tools and adjusts subsequent steps |

Tool access changes what the system can accomplish: it can perform operations rather than only describe them.

Neither interaction alone covers everything a developer needs. Windsurf’s **AI Flows** combine models, context retrieval, and tool calling with an additional input: what the developer is doing. Tracking user actions gives the system evidence about intent, so its next operation can fit the developer’s ongoing work.

Sinha dates the introduction of AI Flows to Windsurf’s November launch and again presents it as influential on other products. The design choice is more useful than the priority claim: put conversational collaboration and autonomous execution in one interface. The developer can discuss a task and remain involved while the same agent retrieves information and performs work.

### Use developer activity to infer intent

[7:17](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=437s)

**Flow awareness** is the connection between activity in the editor and the agent’s understanding of the task. A prompt contains explicit instructions, but the developer’s actions also carry information about what matters. Sinha describes Cascade’s design as tracking edits, commands, terminal commands, clipboard contents, and recently edited files to infer that implicit intent. His clipboard description is a historical product claim, not a blanket statement about collection settings; current [Tab documentation](https://docs.devin.ai/desktop/tab/overview) makes clipboard context opt-in. The linked documentation now uses Devin Desktop branding, while the product names here follow the recording.

Those activity signals enter the agent’s context and inform its trajectory—the sequence of steps it chooses to pursue. Recent work helps it select actions that fit what the developer has already been doing, while accumulated interactions provide further context about the user.

That is why Cascade or Windsurf Tab can appear to anticipate the next action. Sinha compares the effect to predicting the next token: here the target is the developer’s likely next step. The mind-reading language is an analogy for inference from context. The mechanism is that user activity and interaction history reach the context window, giving the assistant information a general-purpose, independent agent would otherwise lack.

### Ground the next step in the repository

[8:53](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=533s)

Understanding the developer answers only part of the problem. The agent also needs explicit knowledge of the codebase. Sinha describes Windsurf’s context engine as combining multiple tools rather than relying on retrieval-augmented generation or embedding search alone. The goal is comprehensive repository understanding, so a suggestion fits the code that actually exists.

User context and repository context then work together: one indicates what the developer likely wants, and the other constrains what makes sense in this project. Sinha attributes more relevant suggestions and fewer hallucinations to this grounding, with the codebase serving as a central source of truth. These are qualitative benefits in the talk; he does not supply a retrieval algorithm or a comparative benchmark.

![Slide titled “Deep understanding of your explicit knowledge,” with panels for semantic repository understanding and full repository context awareness, alongside four stated benefits.](https://ai.engineer/api/talk-essay-media/b638ce6c2aa3bab81b6898afb9f13d7cd5d76dfe18fd6c720134d6804d851893)

Repository understanding and context awareness ground the knowledge base.

### Give the agent tools and a procedure

[9:46](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=586s)

Context makes a next step better informed; tools make it executable. Cascade can perform multiple steps and call [Model Context Protocol servers](https://docs.devin.ai/desktop/cascade/mcp), extending the capabilities available to the agent beyond producing a single response.

[Workflows](https://docs.devin.ai/desktop/cascade/workflows) address a different problem: an agent can choose an unpredictable path through a task. A workflow lets the user specify steps for it to follow. Sinha contrasts that structure with autonomous behavior and describes workflows as deterministic. The useful distinction is a repeatable procedure, however, not a guarantee that model-driven execution or its results will be identical every time.

Instructions and retained context provide two further ways to guide execution:

- **Rules:** User-authored instructions can apply to particular files, apply consistently, or be consulted selectively. They express how the developer wants the agent to behave.
- **Memories:** Cascade can generate retained information about user preferences and the codebase. Sinha presents this as reducing repeated indexing and retrieval. The documented [memory mechanism](https://docs.devin.ai/desktop/cascade/memories) is stored context retrieved when relevant, so it should not be understood as eliminating retrieval.

A workflow supplies a procedure, a rule supplies a constraint or preference, and a memory preserves information that may help with later work.

The same approach extends to multiple simultaneous Cascades. Sinha describes concurrent trajectories that understand one another, the user, and the codebase, and presents them as a route to faster work. That is not a measured speedup or a guarantee of coordination: the [Cascade documentation](https://docs.devin.ai/desktop/cascade/cascade) warns that simultaneous edits to the same file can race and fail. His mention of A2A places the feature in the broader discussion of multiple agents; it does not establish support for that protocol. Web search is another available tool, adding outside information to an agent experience still centered on the developer’s task.

### Discover the task, then make completion explicit

[11:48](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=708s)

The engineering process remains recognizable: **discover → plan → build → test**. Cascade can participate at each stage, but getting useful work from it starts before file edits. Discovery establishes what the task is; planning makes the route to completion inspectable.

Start by making the task concrete:

1. Explore the codebase with Cascade and scope the work.
2. Discuss the goals and state the **definition of done** explicitly.
3. Use `@mention` to provide direct context from relevant files and directories.

An agent may infer its own completion criteria. Discussing them first helps align its stopping point with what the developer actually needs.

Next, work with Cascade on a planning file instead of giving it one broad prompt to build everything. Write a set of tasks, optionally as checkboxes, that lead to the definition of done. The document gives both participants a shared reference for what remains unfinished. Add rules that describe the behavior and preferences the agent should follow while carrying out that plan.

### Build against the plan and correct direction

[13:10](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=790s)

During implementation, use the planning document to track progress as Cascade edits one file or several files. Check that it is working through the intended tasks and updating the checklist. When it asks questions or checks in, answer clearly: those exchanges are opportunities to resolve ambiguity before more work accumulates.

Feedback can correct an implementation, change what the agent examines first, or reprioritize the next steps. Windsurf Tab offers a more hands-on mode through autocomplete when the developer wants to work directly in the editor. Simultaneous Cascades can support separate lines of work, while MCP servers provide additional context and tools. These are different ways to participate in the same build process, with the plan remaining the common reference.

### Test the result before handing it off

[13:58](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=838s)

Testing closes the loop between the agent’s changes and the task’s requirements:

1. Generate tests with Cascade.
2. Run them and work through failures iteratively.
3. Use workflows to automate recurring test-and-fix steps.
4. Compare the result with the original definition of done.

A completed sequence of edits is not by itself proof that the task is complete. If the result misses a requirement, explain the gap to Cascade.

Sinha describes that feedback as helping Cascade learn about the developer, using the language of an embedding representation. Treat this as his account of the intended learning behavior, not an established implementation detail. The immediate engineering purpose is concrete: make the unmet requirement explicit, correct the result, and then commit to Git and push functional code.

![Discover → Plan → Build → Test slide listing Cascade test generation, terminal access, workflows, definition-of-done checks, and committing as tests pass.](https://ai.engineer/api/talk-essay-media/098fd5c2cf5c495a9c67f595755555f3442c6d9cf3a8c35b823650f443b1a94d)

The Test step covers test generation, completion checks, and iterative Git commits.

The closing boundary is continued participation. Think of Cascade as a pair programmer working with you toward the task. Sinha cautions against assigning work, leaving, and returning half an hour later expecting it to be correct; that is a hypothetical unattended-work pattern, not a reliability threshold. His judgment at the time of the talk is that LLMs are not dependable enough for that expectation. Stay involved in the decisions, the corrections, and the verification that turn generated changes into finished engineering work.

## Resources

- [Windsurf's original launch account](https://khou22.com/blog/2024-11-14-introducing-windsurf-editor) — A launch-team account of Cascade, developer intent and the original Windsurf Editor.
- [Cascade overview](https://docs.devin.ai/desktop/cascade/cascade) — Current Cascade documentation covering tools, real-time context and concurrent editing limitations.
- [Create reusable Cascade workflows](https://docs.devin.ai/desktop/cascade/workflows) — Define Markdown task sequences and invoke them with slash commands, including test-and-fix routines.
- [Cascade memories and rules](https://docs.devin.ai/desktop/cascade/memories) — Documentation for retaining conversational context and supplying reusable behavioral instructions.
- [Connect MCP servers to Cascade](https://docs.devin.ai/desktop/cascade/mcp) — Configure external tools for Cascade through MCP servers and administrative controls.
- [Tab suggestions and context settings](https://docs.devin.ai/desktop/tab/overview) — Current guidance for autocomplete, suggested edits, navigation and optional clipboard context.

## Slides

### Mastering Agentic Engineering Flow

Eashan Sinha introduces a talk on making the most of agentic flows in IDEs and how those flows can make developers better.

[0:26](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=26s) [Title slide for Eashan Sinha’s talk on collaborative flows and agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/d3050ba30340474fb75d3daf4905daea963b1cb9f120148d289d1642d80f2f8a.webp)

Windsurf

Mastering Agentic Engineering Flow
HOW COLLABORATIVE FLOWS MAKE BETTER AGENTS

Eashan Sinha
Engineering at Windsurf

### Windsurf Editor

The editor screenshot pairs code changes with Cascade’s analysis of directories and a codebase search for a model-package migration.

[0:39](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=39s) [Windsurf Editor slide showing a laptop with code and the Cascade agent interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/e32e9ac1ad53e17bc65bd19a7a08546c1355f9840b4852cc1364b9107956da40.webp)

Windsurf Editor

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

CASCADE
Agentic reasoning with human-in-the-loop multi-step action task completion.

AIE
Microsoft
smol ai
AI Engineer World’s Fair

Interface text:
public class PatronEventsHandler {
    [illegible]
    return API.Match(book).of(
        [illegible]
    );
    [illegible]
    return book;
    [illegible]
    domainEvents.publish(
        new BookDuplicateHoldFound(
            [illegible]
        ));
    return onHold;
    return book;

Cascade | Write mode
The code in @src/main uses [illegible]. Help me perform a migration to use [illegible] instead.
I’ll help you migrate the code from using the model package to the new_model package. First, let me analyze both directories to understand what we’re working with.
Let me check what files are in both directories:
Let me check the contents of the new_model directory as well:
I’ll need to find all the files in src/main that reference the old model package. Let me search for these references:
Searched codebase — 29 results
I see that we need to migrate several files from using the old model to the new model. Let me first examine the key files in both packages to understand the structural changes.
Let’s look at the core Book class in both packages:
Keep Changes
Discard
Edited files 4/4

### Tom and Jerry

The speaker uses Tom and Jerry’s fight to illustrate developers’ frustration with coding agents that misunderstand requests, duplicate code, or remove code unexpectedly.

[2:21](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=141s) [An angry Tom holds Jerry, who grimaces.](https://assets.ai.engineer/sites/aiecode2025/sha256/96749947e915e01b42a3aef251789e6a1794aa504cb267718c9ae722c7d77e3b.webp)

### Developers and coding agents

A smiling Tom and Jerry stand in for developers and coding agents. The speaker urges developers to treat agents as teammates.

[2:59](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=179s) [Tom and Jerry smiling together, labeled developers and coding agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/e69fe318c3f368687782f8fb2b83f1a30f420eceb4e41a303e2708f4d25e9b09.webp)

DEVELOPERS
CODING AGENT

### How do we fix this problem?

The speaker says tool builders are responsible for helping coding agents understand developers, then asks how Windsurf approaches the problem.

[3:24](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=204s) [Slide says, “It’s not your fault - it’s ours. But how do we fix this problem?”](https://assets.ai.engineer/sites/aiecode2025/sha256/9f08b55689b09159a0f201fb251713bfdba31b952a910abee5bcf8a7f1295ac2.webp)

It’s not your fault - it’s ours.

But how do we fix this problem?

AIE

AI Engineer World’s Fair

### Evolution of AI

Before explaining Windsurf’s approach, the speaker traces how AI evolved into coding agents.

[3:27](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=207s) [Title slide reading “Evolution of AI.”](https://assets.ai.engineer/sites/aiecode2025/sha256/17fbd70a93bf5fb7500f265c99306a9087a656c0524c3a71ba90982442fa1405.webp)

Evolution of AI
Windsurf

AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Evolution of AI

The slide traces coding from manual work to copilots that assist individual steps, then to agents that can research, edit, and execute tasks while a human reviews their work.

[3:43](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=223s) [A timeline illustrates manual coding work before 2022, including navigation, edits, execution and research.](https://assets.ai.engineer/sites/aiecode2025/sha256/0c5ea2e98fbc962e5a45f4a98c63f0e71c5116069dd32b0d221cb4c1f656c0d8.webp)

Evolution of AI

HUMANS
Pre 2022: Manual work, with every line of code being typed by hand.

Workflow: Navigate, Edits, Execute, Research, Grep, Add File

Windsurf
AIE
AI Engineer World’s Fair

[4:24](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=264s) [Slide compares manual coding, copilots and agents with workflow diagrams.](https://assets.ai.engineer/sites/aiecode2025/sha256/40f7c6a2d793e9da9e087b876830626f4abdfdb839c1b8967777583893bf450a.webp)

Evolution of AI

HUMANS
Pre 2022: Manual work, with every line of code being typed by hand.
Workflow: Navigate, Edits, Execute, Research, Grep, Add File

COPILOTS
2022-23: AI-powered suggestions assist with tasks like autocomplete and command help (think: bot / Q&A).
Workflow: Navigate, Edits, Execute, Research, Grep, Add File
Autocomplete
Command
Chat
Knowledge Sources

AGENTS
2024: Hype around AI-driven agents autonomously managing tasks using advanced reasoning (think: intern you can push work to).
Human workflow: Navigate, Call Agent, Research, Edits, Review Agent
Agent workflow: Research, Edits, Execute
Knowledge Sources

Windsurf
AIE
AI Engineer World’s Fair

### AI Evolution: Copilots, Agents, and Flows

Windsurf places Flows between collaborative copilots and autonomous agents, combining models, context and tools with human action tracking.

[4:55](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=295s) [Diagram depicts copilots as collaborative systems using models and context.](https://assets.ai.engineer/sites/aiecode2025/sha256/eaa7d6a2c48793cf1e0ca9618e04fb26a3372a9d82183e967dfc42e00b4c06f8.webp)

AI Evolution: Copilots

Windsurf

V1: ‘Copilots’

V1: Collaborative
MODELS | CONTEXT

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

[5:46](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=346s) [A Venn diagram places Windsurf flows between copilots and agents, with a comparison of their capabilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/ab324d5798c5c8aa82e9610675f8d661c1b835c677dab7caa2242f229a9d78ac.webp)

AI Evolution: Copilots, Agents, and Flows

Windsurf

V1: ‘Copilots’
V3: ‘Flows’
Windsurf
V2: ‘Agents’

V1: Collaborative
MODELS | CONTEXT

V2: Autonomous
MODELS | CONTEXT | TOOLS

V3: Best of Both Worlds
MODELS | CONTEXT | TOOLS
HUMAN ACTION TRACKING

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

### AI Flows

Windsurf combines copilot collaboration with agent autonomy. The diagram shows a developer reviewing edits, changing a file, and deciding whether the agent can run a terminal command.

[6:24](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=384s) [Text describes combining copilot collaboration and agent autonomy; a diagram illustrates a developer and agent working together.](https://assets.ai.engineer/sites/aiecode2025/sha256/021faf15f5312afa2e53fdbbaafd6d985268a62bff71ddcbb1e1ce4f001fa417.webp)

AI Flows

The Windsurf Editor combines the collaborative power of a Copilot with the autonomous capabilities of an Agent, working in perfect sync with you.

Flows create a seamless, unified experience where developers and AI operate as one.

Agent
Copilot
Flows
Copilot-like collaboration merged with agentic independence

“Fix up prime numbers to properly do AKS primarily testing”
Sure, here’s the plan
Analyzed prime_number.py:[1-100]
Edited prime_number.py  +48  -12  Open Diff
Edited aks_primality_test.py  +2  -0  Open Diff

Accept  Reject
Dev edited split.py
“Continue what I was doing”

You edited split.py. This is what I would do
Analyzed split.py
Edited split.py  Open Diff
Run Terminal Command
mv split.py assign_split.py
Yes  No

Windsurf
AIE
Microsoft
smol ai
AI Engineer World’s Fair

### Flow Awareness

Cascade uses a shared timeline of user actions and its own previous steps to infer what the user may do next.

[7:18](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=438s) [A slide describes reasoning about implicit user intent from past actions and a shared timeline, alongside a diagram of context feeding Cascade's next steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/54c9eddf6541e7fb73636b1fb2a9e449a5d47075b13ea9e99c5e917dceb3de7d.webp)

FLOW AWARENESS

Dense reasoning over implicit user intent

Knows your past actions
Always in sync with your flow
Models built to ingest this shared timeline
Infers your next move

Clipboard events
Recently viewed file
Terminal history
Modified files
Conversation history
Lint error
Cascade’s previous steps
Cascade’s next steps

[illegible]ndsurf

### Knowledge base

Windsurf says Cascade combines tools to understand a repository’s structure, grounding suggestions in the codebase and reducing hallucinations.

[8:52](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=532s) [Slide describing repository understanding and its benefits, including grounded results and reduced hallucinations.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea2bf1db7aa9df4e0817f249b7199eb87698ba985f169635f864a17685ae74ea.webp)

KNOWLEDGE BASE
Deep understanding of your explicit knowledge

Deep semantic repo understanding
Cascade understands the meaning and structure of your whole repo.

Full repo context awareness
Cascade is aware of every file, function and folder in your repo.

More accurate, grounded results
Reduced hallucinations
Curated doc awareness
Centralized source of truth

Repository diagram:
remote
useSession
UserProfile
auth.ts
user.ts
session.ts
config.ts

Repository file tree:
components
  Navbar.tsx
  Footer.tsx
  Blog.tsx
utils
  auth.ts
  date.ts
  account.ts
styles
  globals.css
animations
  BlockJump.tsx
  FadeIn.tsx
context
  ThemeContext.t[illegible]

Interface text:
[illegible]ndsurf

### Customizations

Cascade combines MCP tools with user-defined workflows and rules, generates memories, and lets developers start another Cascade while one is running.

[9:46](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=586s) [Slide presenting MCP, workflows, rules, memories, and multiple Cascades.](https://assets.ai.engineer/sites/aiecode2025/sha256/9cad87c052a53ef205942866ec97bca329754f7ec79f51669cb0c447e2857cc4.webp)

CUSTOMIZATIONS
Built to work the way you do, from code to context

MCP
Connect custom tools and services through the Windsurf Plugin store to enhance your AI workflows.

Workflows
Create and save rulebooks that can be invoked from Cascade with autogenerated slash commands.

Rules
Define how Cascade should behave, and it also auto-saves key details about your codebase and workflow.

Memories
Cascade will autonomously generate memories to remember important context between conversations.

Multiple Cascades
Start work in a new Cascade while another one is executing, and never be left waiting.

Interface text:
Plugin store
Search plugins
Figma
Stripe
Github
Slack
Supabase

brainstorm  Help brainstorm next steps
address-PR-comments  ...Github pull request
Write  Chat  Image

Rules  Workflows  Memories
+ Global  + Workspace
When writing React code, comment [illegible]
Project Rules • code-style-guide [illegible]
When the user starts message with [illegible]
Global Rules

Rules  Workflows  Memories
Search memories
Project structure - NextChat
[illegible]
Always use Next.js for web projec[illegible]

Refactoring Rea...
Refactoring React Typescript Com[illegible]
Updating my node version
Create a Footer component
See All Notifications

### Getting the most out of AI flows

After describing tools that help Cascade understand its users, the speaker asks how engineers can get the most out of AI flows.

[11:36](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=696s) [Slide asks how engineers can get the most out of AI flows.](https://assets.ai.engineer/sites/aiecode2025/sha256/f56b0c6593069b94a27663a52647e1f3c41aed04a133688d51f28184ce759070.webp)

As engineers...
How do we get the most out of these AI Flows?

Windsurf
AIE
Microsoft
smol ai
AI Engineer
World’s Fair

### Discover, plan, build, test

The speaker frames engineering flow as a sequence: explore the codebase and scope tasks, plan and build, then test the changes made by the engineer or agent.

[11:58](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=718s) [Slide shows the sequence Discover, Plan, Build, and Test.](https://assets.ai.engineer/sites/aiecode2025/sha256/d309e7b61964d0c611cbe3b458123d57afa512dc4be9afa5390a8947e8d16d9d.webp)

Discover → Plan → Build → Test

Windsurf
AIE
Microsoft
smol ai
AI Engineer World's Fair

### Discover

Use Cascade to explore the codebase, scope tasks, define done, and discuss goals. @mention relevant files and directories to give it direct context.

[12:28](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=748s) [Discover: use Cascade to understand the codebase, scope tasks, define done, discuss goals, and mention relevant files and directories.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e68309bfe62d0857b3c3ad2bca72bee750f7dc36c68d066a19ac4336230a6a2.webp)

Discover → Plan → Build → Test

• Leverage Cascade to understand your codebase
• Scope out your tasks
• Determine your D.O.D. (definition of done) states
• Talk through goals with Cascade
• @ mention relevant files and directories

AIE
Windsurf
AI Engineer World's Fair

### Plan

Create a planning file with Cascade: break the definition of done into small checklist steps, set rules for its behavior, and use @ web to find documentation and current versions.

[12:50](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=770s) [Plan: create a checklist and small steps with Cascade, define behavior rules, and search the web for documentation.](https://assets.ai.engineer/sites/aiecode2025/sha256/d9e3fef45917584ded5038637226619e5910132b6d2152e73c2f910ef3c49cfc.webp)

Discover → Plan → Build → Test

• Create a planning file with Cascade
  ◦ Set a checklist for the things to accomplish to achieve D.O.D.
  ◦ Break into small steps
• Design rules to align Cascade’s behavior with your preferences
  ◦ e.g. a rule to constantly update the plan doc for tracking progress
• @ web to search for documentation and latest versions

Windsurf
AIE
AI Engineer World’s Fair

### Build

Cascade executes the plan against its checklist, while separate Cascades can take on different tasks. Windsurf Tab provides hands-on autocomplete, and MCP servers bring in additional context.

[13:09](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=789s) [Build: execute the plan with Cascade, use autocomplete, assign separate tasks to simultaneous agents, and pull context from MCP servers.](https://assets.ai.engineer/sites/aiecode2025/sha256/fece126639b35ce78875e9f8bdd25e0805e2b3e55326d2e3cfd45c5736da8392.webp)

Discover → Plan → Build → Test

• Execute plan with Cascade
  ○ Edit [one or more] files one by one
  ○ Ensure Cascade is following plan doc with checklist
• Windsurf Tab for hands on, autocomplete experience
• Leverage simultaneous Cascades (multiple agents)
  ○ Have them work on separate tasks
• Utilize different MCP servers to pull context from additional sources

AIE
Windsurf
Microsoft
smol ai
AI Engineer World's Fair

### Test with Cascade

Generate, run, and fix tests one by one with Cascade. Check the plan against the definition of done, then commit functional code as tests pass.

[13:57](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=837s) [Testing workflow: generate and fix tests, use terminal access and workflows, check the definition of done, and commit functional code.](https://assets.ai.engineer/sites/aiecode2025/sha256/a97e415a8df9c68611502c0e5354984095263d8379cdca2ae941784c4846ed73.webp)

Discover → Plan → Build → Test

• Generate tests with Cascade
  ○ Generate, run, and fix tests one-by-one
• Cascade has terminal access for running commands, referencing git worktrees, etc.
• Use “/ workflows” to automate repetitive tasks
• Determine if Cascade achieved your D.O.D.
  ○ Make sure the tasks in the plan doc are all checked
• Commit to git iteratively as the tests pass to push functional code

AIE
Windsurf
AI Engineer World’s Fair

### You + Cascade

Work with Cascade as a pair programmer, collaborating on tasks instead of leaving it to work unattended for 30 minutes.

[14:37](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=877s) [A cream slide reads “You + Cascade =”.](https://assets.ai.engineer/sites/aiecode2025/sha256/2d56cb2a45a4f7413e3ced4b3a7d83e4c6704c0e893a46ba6206a2bc9bb70821.webp)

You + Cascade =

### Windsurf

[15:07](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=907s) [The Windsurf logo appears centered on a black slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/c1a856f8f9eadc132c56e34bde4dbbb384f3dee10d4949abec482f4cd744d194.webp)

Windsurf

AIE
aws
AI Engineer
World’s Fair

## Full transcript

[0:00](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=0s) [on hold music] Hey everyone, um, I'm Eashan.

[0:17](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=17s) 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.

[0:32](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=32s) Um, and also talk a little bit about how these flows make us, um, better developers.

[0:38](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=38s) 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.

[0:50](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=50s) Okay. Sorry, give me one... Will it not share if I... Okay. Um,

[0:58](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=58s) 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,

[1:18](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=78s) 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.

[1:31](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=91s) 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,

[1:41](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=101s) 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.

[1:59](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=119s) 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,

[2:09](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=129s) 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.

[2:19](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=139s) 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.

[2:30](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=150s) 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?

[2:39](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=159s) 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.

[2:51](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=171s) 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?

[3:06](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=186s) 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.

[3:25](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=205s) Um, how do we fix this problem? How does Windsurf approach this?

[3:30](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=210s) 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.

[3:45](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=225s) 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?

[3:55](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=235s) There was just Stack Overflow, um, and Google.

[4:00](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=240s) 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.

[4:19](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=259s) 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

[4:39](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=279s) 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.

[4:57](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=297s) 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.

[5:04](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=304s) 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?

[5:17](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=317s) 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.

[5:33](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=333s) 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.

[5:47](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=347s) What Windsurf has done when we launched was we realized that agents really didn't solve the problems that, um, copilots could solve, and copilots didn't do everything that we would want to do as developers as well.

[5:59](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=359s) And so we took the best of both worlds in that we combined

[6:05](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=365s) 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.

[6:22](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=382s) 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

[6:39](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=399s) 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

[7:01](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=421s) 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.

[7:17](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=437s) 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.

[7:32](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=452s) 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.

[7:42](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=462s) 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.

[7:55](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=475s) 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

[8:14](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=494s) 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.

[8:22](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=502s) 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

[8:40](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=520s) 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.

[8:53](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=533s) 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.

[9:00](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=540s) 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.

[9:16](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=556s) 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?

[9:27](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=567s) 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 aligns with what the user may want, and, um, it's grounded in this centralized, uh, source of truth, which is this codebase that

[9:46](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=586s) 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.

[10:01](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=601s) 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?

[10:14](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=614s) 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.

[10:28](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=628s) 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?

[10:40](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=640s) 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.

[10:51](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=651s) 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.

[11:01](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=661s) And on top of that, recently, there's a lot of talk about A2A, 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,

[11:23](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=683s) 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.

[11:38](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=698s) 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.

[11:48](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=708s) Um, but as engineers, how do we make the most, how do we get the most out of these flows?

[11:54](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=714s) 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.

[12:04](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=724s) 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.

[12:15](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=735s) 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?

[12:25](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=745s) 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?

[12:34](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=754s) 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?

[12:43](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=763s) 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.

[12:53](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=773s) 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."

[13:04](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=784s) Also, outline rules to tell Cascade how to behave that align with your preferences.

[13:10](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=790s) 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.

[13:25](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=805s) 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.

[13:33](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=813s) 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.

[13:45](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=825s) 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.

[13:58](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=838s) 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.

[14:12](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=852s) 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.

[14:22](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=862s) 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.

[14:31](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=871s) Um, and then lastly, then you wanna commit to Git, uh, and, and make sure that you're pushing code that is functional.

[14:39](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=879s) 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 pair programmer, um, you guys are working together to accomplish tasks.

[14:50](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=890s) 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.

[14:58](https://www.youtube.com/watch?v=W_5tzQY-hVs&t=898s) 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]
