Windsurf
Ask it to do a task. Watch it read files, run commands, and iterate until it's done.
You've asked an AI to fix a bug, and it's given you the code change. But you know there will be a follow-up: the tests will fail, you'll paste the error back, it'll propose another fix, the linter will complain, another round. Five rounds to fix a three-line bug. What if the AI could just do all of that itself?
Why this tool matters
Windsurf (from Codeium) is a VS Code fork built around Cascade, an agentic coding mode that can run commands, read their output, and keep iterating until a task is done. It's the closest thing in this course to a real software-engineering agent: you describe a goal, Windsurf plans the steps, executes them, and tells you when it's blocked or finished.
The practical difference from Cursor is subtle but important. Cursor is excellent at
proposing diffs; you still apply them and run the tests yourself. Windsurf's
Cascade mode takes the loop inward: it proposes a diff, applies it, runs the command
you specified (npm test, pytest, pnpm build),
reads the output, and — if something failed — proposes another round. For tasks with a
clear automated signal of success (tests pass, build succeeds, lint is clean), this is
transformative. A 20-minute debugging loop becomes a 2-minute walk-away.
Windsurf also has an extraordinary memory feature: it remembers design decisions, coding preferences, and project-specific context across sessions. The first week with Windsurf feels similar to Cursor; by week three, it has learned enough about your habits that it starts producing work you barely need to edit.
Setup
Install: download from windsurf.com. Sign in with Google, GitHub, or email. Free tier is generous enough for serious evaluation; Pro ($15/month) unlocks more Cascade runs.
Bring: a project with an automated success signal — a test suite, a type checker, a linter, a build command. Windsurf's agentic mode rewards projects where “it works” has a clear definition.
Walkthrough
Step 1: Open Cascade and try a simple task
Open your project. Press the Cascade button in the right sidebar. Type a task that requires looking at the project: “What does the authentication flow do? Walk me through the files involved.” Watch Windsurf open files, read them, and summarize.
Step 2: Now give Cascade a task with an action
Try: “Find the function that validates email addresses. Add support for plus-addressing (foo+tag@bar.com should be valid). Run the tests and fix any that break.” Cascade will locate the function, propose a diff, run your tests, and — if a test fails — iterate.
Step 3: Review the action log
As Cascade works, it shows you every step: the files it read, the commands it ran, the output it saw, the diffs it applied. You can stop it at any time, ask a question, or nudge it in a different direction. This is the transparency that separates Windsurf from black-box agents.
Step 4: Approve command execution
Windsurf asks before running commands that touch your system — installing packages, writing files outside the project, starting servers. Review each request. The default deny-list is sensible, but the value of the tool is maximum when you let it run tests, linters, and formatters freely.
Step 5: Use Memory to lock in style
When you notice Windsurf making the same mistake twice, tell Cascade: “Remember: we use snake_case for database columns, never camelCase.” Windsurf records this to long-term memory. Future sessions will remember, without you re-explaining.
Step 6: End with a checkpoint commit
After a Cascade run, always commit to git with a descriptive message before starting the next task. This gives you a clean revert point and a human-readable audit trail. If a Cascade run goes sideways, git reset --hard HEAD puts you right back where you were.
Your turn
Basic: A single-file fix with Cascade
Find a bug or a small feature in a project you know — something with a failing test, or something where the behavior is obvious (a label is wrong, a number is off by one). Ask Cascade to fix it. Watch it propose the diff, run the tests, and iterate if needed. Read the action log afterward.
Goal: see how different “AI writes and runs” is from “AI writes, I run.”
Advanced: A real refactor with a success signal
Pick a refactor you've been putting off — something with a clear shape: “extract this logic into a module,” “rename this concept throughout the codebase,” “switch from callbacks to async/await in this module.” The key criterion: there must be a clear test command that tells you when the work is done.
Write the task for Cascade in 3-5 sentences, including the success signal: “When this is done, npm test should pass and grep -r "old-name" src/ should return zero results.”
Start Cascade and walk away for 5 minutes. Come back. Read the action log. Review the final diff carefully before committing.
Write a 100-word reflection: what did Cascade do well, and what did you have to correct by hand? That reflection is the skill of being a good pilot of an agentic tool.
Pitfalls and pro tips
Agents love scope creep. If your task description is vague, Cascade will sometimes “helpfully” refactor adjacent code you didn't ask it to touch. Be explicit about boundaries: “Only modify src/auth/ and tests/auth/. Do not touch anything else.”
Running commands without review is dangerous. Cascade can be convinced to run destructive commands (rm -rf, git push --force) if they were implied by the task. Review every command approval prompt. Never auto-approve.
Memory can go stale. After a few months, Windsurf's memory accumulates decisions that no longer reflect how you want to work. Visit the Memory settings quarterly and prune entries that are no longer true.
How it compares
Windsurf and Cursor (Day 6) are the two leading AI-native IDEs; picking between them is often a matter of taste. Rough guidance: Cursor has a slight edge on the quality of inline edit diffs; Windsurf has a slight edge on the agentic Cascade experience. Both integrate every major model (Claude, GPT, Gemini) and both let you bring your own API keys. The right move for any serious developer is to try both for a week and keep whichever fits your habits. Replit Agent is the third strong competitor, notable for running in-browser with a live preview — great for web projects, less flexible for backends or CLI tools.
When to use — and when not to
Use Windsurf when your task has a clear automated success signal (tests pass, build succeeds, lint clean) and would benefit from multi-step iteration — refactors, bug-hunting, adding features that span many files.
Do not use Windsurf when you're exploring an idea and want to think at the keyboard (inline edits in Cursor or a regular editor are better for that), or when the task has no automated signal (visual design, UX copy, product decisions). Agents without a success signal tend to loop.