AI Engineer World's Fair 2025

Mastering Engineering Flow with Windsurf

Loading slides…

Read the talk

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.

From a talk by Eashan Sinha

Before you start: 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?

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 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.Open full source frame
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.

0:170:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:17 · section reference included

From single responses to collaborative execution

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.

InteractionContextExecution
Prompt–response copilotDeveloper supplies files and detailsReturns a response; developer advances the work
Iterative agentRetrieves relevant contextCalls 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.

3:303:45
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:30 · section reference included

Use developer activity to infer intent

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

7:177:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:17 · section reference included

Ground the next step in the repository

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.Open full source frame
Repository understanding and context awareness ground the knowledge base.
8:539:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:53 · section reference included

Give the agent tools and a procedure

Context makes a next step better informed; tools make it executable. Cascade can perform multiple steps and call Model Context Protocol servers, extending the capabilities available to the agent beyond producing a single response.

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

9:4610:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:46 · section reference included

Discover the task, then make completion explicit

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.

11:4811:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:48 · section reference included

Build against the plan and correct direction

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.

13:1013:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:10 · section reference included

Test the result before handing it off

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.Open full source frame
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.

13:5814:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:58 · section reference included

Resources

Updates since the talk

Transcript download
Full transcript

Loading transcript…