Windsurf for Serious Builders: Cascade, Rules, and Agent Workflows

Windsurf is no longer called Windsurf. On 2026-06-02, Cognition, the company behind the autonomous Devin agent, rebranded the IDE it acquired from Codeium to Devin Desktop, with most windsurf.com pages now redirecting to devin.ai (Devin Desktop changelog).

The Cascade agent, .windsurfrules, and the MCP setup all carry over unchanged. But the brand is moving, and Cascade as a separately named product is slated to retire on 2026-07-01 in favor of a Rust runtime called Devin Local.

That churn is exactly why a power user needs a current map. This guide covers what actually ships in the Windsurf AI IDE as of June 2026: Cascade Flows, the rules and memories layers, MCP, the adaptive router, and the verification loop that keeps agentic coding from going off the rails.

TL;DR: Windsurf for power users in mid-2026

The fastest path to leverage in Windsurf is configuration, not prompting. A small .windsurfrules file (under 200 lines), domain-scoped Memories, an honest .codeiumignore, and one real MCP server beat any amount of clever phrasing. Cascade's default adaptive router (on since 2026-04-06) picks a model per task, so you mostly leave it on Auto and pin a model only for cost-sensitive batches. The current editor build is v3.1.7 (verified 2026-06-10), Pro is $20/month after the March 2026 restructure, and the whole thing now ships under the Devin Desktop brand.

Key takeaways

• Windsurf rebranded to Devin Desktop on 2026-06-02; Cascade behavior carries over but the brand is in motion.
• Cascade has two interaction modes (Write/Code and Chat) and one runtime concept (Flows, a single agentic run with checkpoints).
• .windsurfrules + Memories + AGENTS.md are three distinct config layers; keep rules short or they get dropped.
• MCP support is the most complete of the major AI IDEs: marketplace, OAuth, three transports, per-tool toggles.
• Pin a model for predictable ACU spend on batches; trust the router for unknown one-off tasks.

What is Cascade, and how do Flows actually work?

Cascade is the agent in Windsurf's right-hand panel. Current docs split it into two interaction modes and one runtime idea.

Write mode (called Code mode in the JetBrains build) is the agent that edits files, runs terminal commands, and iterates. Chat mode is read-only Q&A against your codebase and open tabs, good for plan-only sessions and quick reading (Cascade overview).

A Flow is a single Cascade agentic run. It has a named lifecycle, emits checkpoints, and pauses before terminal or destructive operations to ask for confirmation (Workflows docs). Flow is not a "mode," it is one execution.

In practice, a Write-mode turn looks like this: you describe a change in plain language, Cascade reads the relevant files, proposes a plan, applies a multi-file diff, and surfaces it in diff zones where you accept or reject each hunk. Named Checkpoints (shipped in Wave 13) let you rewind a Flow to an earlier point instead of trashing the whole run.

The habit that compounds: start a Flow with one or two named files plus a one-line goal. Tighter scope means smaller diff zones and less partial work to babysit.

How does the adaptive router pick a model?

The thing that distinguishes Cascade from a generic "agent that edits code" is the adaptive router, the default model selector for most users since 2026-04-06 (Adaptive docs).

When the picker is on Auto, Cascade calls a small classifier first and routes the work: SWE-1.6 for repo-wide refactors, Claude Opus 4.7 for ambiguous requirements, GPT-5.4 for short edits, and a small swe-grep subagent for fast codebase search (SWE-1.6 launch).

You can pin a model in the picker when you want predictable cost and latency. That is the right move for a batch of similar edits, where the router might occasionally reach for Opus 4.7 and burn credits you did not budget.

Credits are metered in ACUs (Agent Compute Units), and the live per-model rates live in the Cascade Models page.

What's current: models and pricing (June 2026)

Here is the version-specific snapshot. Treat it as dated, because the picker changes most months.

The Sonnet 4.6 1M-token standard tier is dated 2026-03-13 in Simon Willison's coverage. GPT-5.1 was quietly pulled from the picker around 2026-03-11 (third-party reported, not confirmed in an OpenAI changelog). On pricing, the March 2026 restructure set Pro at $20/month, a new Max tier at $200, and Teams at $80/team plus $40/dev (pricing post).

Rules, Memories, and AGENTS.md: three layers, not one

Windsurf has three config surfaces that beginners constantly conflate. Keeping them straight is the single biggest power-user upgrade.

.windsurfrules is a Markdown file at your repo root, injected into every Cascade prompt. It supports frontmatter for description, globs, and alwaysApply (Agents.md docs). A workable TypeScript block:

---
description: TypeScript and React conventions for Cascade
globs: ["**/*.{ts,tsx}"]
alwaysApply: true
---

- Use TypeScript strict mode; never add `any` without an explicit comment.
- Prefer named exports; default exports only for React components.
- Every new component needs a colocated `.test.tsx` with one render test.
- Use TanStack Query for server state, Zustand for local UI state.
- Run `tsc --noEmit` and `vitest run` before reporting completion.

Memories are separate from rules and survive across sessions and machines. There are two scopes: a workspace memory in the repo (typically .windsurf/memories/) and a user-global one in your home directory (Cascade Memories). You can tell Cascade "remember that this project uses uv" and it surfaces relevant memories at the start of a new Flow.

AGENTS.md is a repo-level hand-off file Cascade reads on every Flow, separate from your rules. Use it for architecture notes and known landmines you do not want bloating the global rule list.

Keep rules short or they get silently dropped

The most important rules habit is brevity. A community benchmark on the awesome-windsurfrules repo found that rules past roughly 150 lines started being silently dropped by Cascade in 22 of 25 sampled runs.

That is a single-repo community report, not a controlled study, but it points the right way: keep .windsurfrules under 200 lines, scope Memories to one file per language or service, and use globs aggressively so a rule never reaches files it should not touch.

How do you set up MCP in Windsurf?

MCP (Model Context Protocol) gives Cascade hands outside the editor: GitHub, Slack, Postgres, your docs. Configure servers in ~/.codeium/windsurf/mcp_config.json (or the %USERPROFILE%\.codeium\windsurf\ path on Windows), or use the MCP Marketplace in the Cascade panel for one-click installs of verified servers (Cascade MCP docs).

A minimal GitHub server config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}" }
    }
  }
}

Cascade supports three transports (stdio, Streamable HTTP, and the older SSE), all with OAuth, plus ${env:VAR_NAME} interpolation in command, args, env, and URL fields. The default tool cap is 100 per session, and you can disable individual tools under Settings → Cascade → MCP Servers.

GitHub maintains an official Windsurf install guide in their github-mcp-server repo.

GitHub and Slack are the two first-party named example servers; filesystem, Postgres, and Playwright are community configs that work but are not officially blessed. Teams and Enterprise plans can enforce an MCP whitelist, a custom registry, and regex allow/deny patterns.

One trap for Enterprise: MCP is opt-in there, so you have to turn it on manually.

Context awareness is where power users pull ahead

The gap between casual and serious Windsurf use is mostly how much context Cascade is actually given.

Turn on local indexing for any repo past a few hundred files. The indexer chunks files into embeddings that power @codebase and make first-turn reads cheap; without it, Cascade falls back to slower ripgrep-style file walks (local indexing docs). Teams and Enterprise extend this with remote indexing for monorepos.

The full @-mention set is @file, @folder, @docs, @codebase, @terminal, and @web. Prefer @codebase over the implicit "read everything" path for any question where you already know the file. Fast Context pre-computes a lightweight dependency graph for the file under edit so follow-ups read less of the repo (Fast Context docs).

Keep a .codeiumignore honest. Excluding node_modules and .venv at a monorepo root keeps the indexer fast (Windsurf Ignore docs). Do not let that file grow into a junk drawer.

The verification loop that actually works

Agentic coding still lives or dies on verification. The recipe that holds up in mid-2026:

1. Start a Flow with one or two tightly scoped files.
2. Let Cascade propose a plan, and accept it before any edit. A Flow that starts with an edit produces a worse diff than one that starts with a plan you approved.
3. Watch the diff zones and accept or reject per hunk. This is the most under-used feature in casual usage and the biggest time-saver on large refactors.
4. Let Cascade run your test command (pnpm test, pytest -q) before reporting back.
5. If a Flow goes sideways, rewind to the last checkpoint and constrain scope instead of discarding the run.
6. Once green, use AI Commit Messages for a Conventional Commits message and ship.

Cascade pauses before any terminal command, and .gitignore access for terminal operations is opt-in per workspace. Worktrees (Wave 13) let a long Flow run on a side branch while you keep editing main.

Where Windsurf wins, and where it doesn't

No single AI IDE dominates in 2026. The honest comparison, as of 2026-06-16:

Windsurf leads on MCP UX and context surfaces, and it is the only one of the four with a default-on adaptive router and a serious local runtime story in Devin Local. Cognition claims roughly 30% token efficiency from the Rust rewrite, though that figure is vendor-reported and not independently benchmarked (SWE-1.6 post).

Where it trails: Claude Code is the stronger terminal-native agent for long-horizon, multi-step work; Cursor's Composer 2 is faster on small chatty edits (Cursor changelog); and Copilot still owns the Microsoft stack. The real risk is brand stability: the 2026-06-02 rebrand and 2026-07-01 Cascade EOL mean teams standardized on the Cascade panel face migration ahead.

On the productivity numbers, be skeptical. The "1M+ developers" and ">50% of new code is AI-generated" claims are vendor self-reports, not independently audited. The citable facts here are release dates and the per-model ACU rates in the docs, not the impact stats.

What this means for you: a setup checklist for this week

1. Update to v3.1.7 (or current on the Devin changelog) before configuring anything.
2. Drop a .windsurfrules at the repo root and keep it under 200 lines.
3. Add a .codeiumignore for vendored deps and generated code.
4. Wire up one MCP server you will actually use. GitHub via the marketplace is the lowest-friction first install.
5. Add a workspace memory for "how to run tests here" and "what not to touch."
6. Pin a model for the first week to learn your credit spend, then switch to the adaptive router.
7. Treat Cascade as a pair, not an oracle: plan first, accept hunks, rewind to a checkpoint when a Flow drifts.

The product is mid-transition. The agent surface is solid; the brand and the model picker are not. Pin a version, write a small rules file, and re-evaluate in 90 days.

Sources

• Devin Desktop changelog
• Introducing SWE-1.6, Cognition
• Cascade Models, Windsurf Docs
• Adaptive, Windsurf Docs
• Cascade Workflows, Windsurf Docs
• Cascade MCP Integration, Windsurf Docs
• Agents.md, Windsurf Docs
• Cascade Memories, Codeium Docs
• awesome-windsurfrules, GitHub
• github-mcp-server Windsurf install guide
• Local Indexing, Codeium Docs
• Fast Context, Windsurf Docs
• Windsurf pricing changes, Windsurf Blog
• Introducing Claude Sonnet 4.6, Simon Willison
• Claude Code, Anthropic