Windsurf — Module 22.6

How This Lesson Fits the Module & Volume

Cursor established the AI-native VS Code-fork pattern. Windsurf (Cascade) is the peer students will see in bake-offs: another AI IDE with autocomplete plus an agentic flow, from the Codeium lineage. Vendor entity and SKU names have shifted over time—treat “Windsurf / Cascade / Codeium” as one product family and re-read the current homepage before procurement. Vol. 21 coding assistants still apply: HITL diffs, context budgets, internal tests.

Vol. 15 agentic workflows explain Cascade as a flow (stateful agent) rather than a one-shot complete. Vol. 18 deployment is unchanged: the IDE does not replace CI. Next: GitHub Copilot—the plugin that lives inside IDEs you already own.

Learning Objectives

By the end of this lesson, students should be able to:

Describe Windsurf as an AI IDE whose headline agent is Cascade, with Supercomplete-class autocomplete.
Contrast Cascade flows (memories, multi-step) vs Tab-style ghost text.
Apply the same privacy/repo-index discipline as Cursor (ignore, no secrets, HITL).
Run a qualitative bake-off: Cursor vs Windsurf vs Copilot on the same internal tasks.
Know when Windsurf wins (flow UX, Codeium-family accounts) vs when Copilot/Cursor wins.
Refuse treating acquisition headlines as a substitute for a current DPA and plan sheet.

Definition

Windsurf is an AI-first desktop IDE (VS Code-like) whose agent surface is typically branded Cascade: a multi-step coding agent that can read the workspace, edit multiple files, and keep memories / flows across a session. Autocomplete (historically Supercomplete in the Codeium family) remains the low-latency ghost-text path. Windsurf is a coding-assistant product, not a license to run unsupervised production writes. Confirm current publisher name, privacy FAQ, and plan meter before you cite them in an RFP.

Cascade vs Supercomplete

Surface	Job	Context	HITL bar
Supercomplete / Tab-class	Next-token / next-chunk in the buffer	Local file + light neighbors	Keystroke accept/ignore
Inline command / chat	Edit this selection	Selection + prompt + optional files	Review in-buffer diff
Cascade flow	Multi-file implement / repair / explain	Workspace retrieval + memories + tool output	Review plan + diff + tests (Vol. 15 loop)

Memories and flows are useful working memory (Vol. 15 memory)—they are not a durable system of record. Do not store secrets in Cascade memories. Do not assume a flow survives a new laptop without export/policy.

Cascade shines

Guided multi-step refactors
Test-fail → patch loops
Onboarding (“how does auth work?”)

Autocomplete shines

Idiomatic next lines
Low-latency pairing
When you already know the design

Neither replaces

Code review + CI (Vol. 18)
Secret scanning
Internal pass@k eval (Vol. 21)

Privacy and Repo Context

Same physics as Cursor: an index improves Cascade; an index of .env is a Vol. 20 incident. Use ignore files, redact credentials, and prefer team plans that document no-train / retention. If legal asks “does Windsurf train on our repo?” answer from the current privacy page and DPA—not from a tweet about Codeium circa 2023.

Catalog Snapshot (Qualitative)

Dimension	Windsurf	Cursor	GitHub Copilot
Pricing posture	Individual/team seats; Cascade/premium usage often capped or metered—confirm live sheet	Seats + agent/premium usage	Seat tiers + premium requests on some SKUs
Strengths	Cascade flow UX; memories; Codeium-family autocomplete heritage; VS Code-like shell	Agent + Tab in a very popular fork; project rules culture	Multi-IDE; GitHub enterprise path; content exclusion
Weaknesses	Vendor/brand churn; smaller default enterprise story than Microsoft; bake-off required	Fork lag vs upstream; not native JetBrains	Less AI-native chrome; agentic depth varies by surface
Agentic vs autocomplete	Cascade vs Supercomplete—keep them separate in policy	Agent vs Tab	Chat/Edits/Agent vs ghost text
Privacy / repo	Index + ignore + team privacy claims (verify)	Privacy Mode + ignore + Business	Content exclusion + org no-train (verify)

Bake-off Harness (Same Tasks, Two IDEs)

Do not declare a winner from marketing GIFs. Run the Vol. 21 internal suite on a repo you own.

# bakeoff_ide.py — educational scorecard (systems you maintain)
from dataclasses import dataclass, field

TASKS = [
    "tab: complete a pure helper from its docstring",
    "inline: rename + update call sites in one package",
    "agent: add a FastAPI route + pytest (Vol. 18)",
    "qa: explain auth middleware from retrieved files only",
]

@dataclass
class Trial:
    ide: str          # "windsurf" | "cursor" | "copilot"
    task: str
    accept: bool
    revert: bool
    ci_green: bool
    notes: str = ""

@dataclass
class Scorecard:
    trials: list = field(default_factory=list)

    def summary(self) -> dict:
        out = {}
        for t in self.trials:
            s = out.setdefault(t.ide, {"n": 0, "accept": 0, "revert": 0, "ci": 0})
            s["n"] += 1
            s["accept"] += int(t.accept)
            s["revert"] += int(t.revert)
            s["ci"] += int(t.ci_green)
        return out

# Policy: same ignore rules, same test command, same human reviewer.
# Forbidden: exploit/malware tasks; pasting .env; claiming public leaderboard numbers.

When to Pick Windsurf

Pick Windsurf when

Cascade flows + memories win your internal bake-off.
The team already has Codeium-family accounts or muscle memory.
You want an AI-native IDE but Cursor did not fit UX/price/privacy.
VS Code-like bindings are acceptable.

Pick something else when

Microsoft/GitHub estate + multi-IDE → Copilot.
Cursor Agent + rules already standardized.
Legal has not finished the Windsurf/Codeium entity + DPA review.
You need a browser prototype, not a desktop IDE → Bolt / Lovable / Replit.

Related Lectures

Lecture	Role
Cursor	Peer AI-native fork; same bake-off protocol
Coding assistants	Accept / revert / CI metrics
Memory / agent loop	Cascade memories vs durable state
Deployment	CI still ships the diff
GitHub Copilot	Next: plugin, not fork

Common Misconception

“Windsurf is just Cursor with a different skin.” Cascade flows/memories and Copilot’s GitHub gravity are distinct product bets—bake off. Second: Codeium autocomplete history means Cascade is only ghost text. Third: acquisition rumors freeze your DPA forever. Fourth: memories are a secrets vault. Fifth: a generous free tier (if any) is a production cost model. Sixth: inventing benchmark win-rates from social media.

Knowledge Check

Short Answer: What is Cascade in Windsurf? Answer: The multi-step / agentic coding flow (not mere ghost text).
True/False: Supercomplete-class autocomplete and Cascade are the same HITL bar. Answer: False—autocomplete is keystroke; Cascade is plan + multi-file review.
Multiple Choice: Cascade memories are closest to: (a) Vol. 15 working memory, (b) a PCI secrets manager, (c) Kubernetes etcd. Answer: (a).
Short Answer: Name the three IDEs in this lecture’s qualitative catalog table. Answer: Windsurf, Cursor, GitHub Copilot.
True/False: You should cite a memorized dollar price for Windsurf seats. Answer: False—use qualitative posture and the live plan sheet.
Multiple Choice: A fair bake-off measures: (a) accept/revert/CI on internal tasks, (b) only Twitter GIFs, (c) HumanEval screenshots as prod proof. Answer: (a).
Short Answer: Why re-check vendor entity before a DPA? Answer: Windsurf/Codeium ownership and brand have shifted; legal needs the current party.
True/False: Windsurf deployment replaces Vol. 18 CI. Answer: False.
Multiple Choice: Next lecture is: (a) Zapier, (b) GitHub Copilot, (c) Veo. Answer: (b).
Short Answer: Name one reason to pick Copilot over Windsurf. Answer: Multi-IDE requirement or GitHub enterprise / content exclusion path.

Key Takeaways

Windsurf is the Cascade-centered AI IDE from the Codeium lineage—verify current vendor and privacy docs.
Keep autocomplete and Cascade in separate policy buckets (Vol. 15 HITL).
Bake off against Cursor and Copilot with internal accept/revert/CI metrics.
Pricing is seat + usage posture; no invented dollar figures.
Next: GitHub Copilot.

Trainer’s Guide

Lab: Same four-task scorecard on Windsurf vs Cursor (pair teams). Share ignore files. Discuss where Cascade memories helped vs leaked scope.

Seminar: Read the current Windsurf privacy FAQ aloud. Strike any sentence students cannot source. Preview Copilot as “stay in JetBrains / VS / nvim.”

Recap: Windsurf is Cursor’s bake-off peer: Cascade flows versus Tab, same privacy physics, same Vol. 18 ship path. Continue to GitHub Copilot.