AI AI Tools Guidebook
AI Tool Tutorials

Windsurf (Now Devin Desktop): 30 Minutes to a Working AI-Coding Loop

Set up Windsurf — rebranded Devin Desktop in June 2026 — install, sign in, write a rules file, and ship your first reviewed multi-file Cascade diff.

Published: Updated: Author: AI Productivity Guide Team 🌐 查看中文版本

TL;DR

A linear thirty-minute path from “I just installed Windsurf” to “the agent shipped a small multi-file change I actually trust.” Install Devin Desktop (the app Windsurf became on June 2, 2026), sign in, let indexing finish, write a .devin/rules/ file, then run one tightly scoped agent task and accept a clean, reviewed diff. The mistake new users make is asking for a giant refactor on the first run and bailing when the diff is unreadable. Don’t do that.

One thing changed since you last heard of Windsurf

Windsurf was acquired by Cognition (the team behind Devin) in December 2025, and on June 2, 2026 the editor was renamed Devin Desktop. Same VS Code-based IDE, same keybindings, extensions, and LSPs — fully backwards-compatible with your old Windsurf setup, and existing installs updated over the air. Two naming notes for this guide:

  • The desktop app now installs as Devin (Devin.app on macOS). Older builds still say “Windsurf.”
  • The agent panel, historically called Cascade, is being replaced by Devin Local — a from-scratch Rust rewrite that Cognition says is roughly 30% more token-efficient and adds subagents. Legacy Cascade stays available through July 1, 2026. This guide uses “Cascade / Devin Local” interchangeably for the agent.

Everything below works on both the latest Devin Desktop build and an older Windsurf install.

Key concepts

  • Cascade / Devin Local: the agentic mode — multi-step, multi-file, runs tests and shell commands when you allow it.
  • Write / Chat / agent triangle: three interaction modes. Write is inline completion, Chat is conversational Q&A, the agent (Cascade / Devin Local) does the multi-file work.
  • Rules: pinned project context files the agent treats like a system prompt. As of June 2026 these live in .devin/rules/ (preferred) or AGENTS.md; the legacy .windsurfrules and .windsurf/rules/ still load.
  • Codemaps: AI-annotated visual maps of your codebase — entry points, data flow, per-node explanations. Useful for orienting before you let the agent touch anything.

Who this is for

Developers who already use one AI coding tool (Copilot, Cursor, Claude Code) and want a second opinion, or a tighter agent loop than Cursor’s Composer feels like. You should be comfortable with VS Code keybindings. If you have never used an AI IDE, do Cursor for beginners first — Windsurf is far easier to evaluate once you know what an “agent diff” looks like.

What it costs (as of June 2026)

Windsurf/Devin Desktop pricing moved off the old credit system to daily and weekly quotas that refresh automatically. Pro rose from $15 to $20 in March 2026, matching Cursor Pro.

PlanPrice (USD/mo)What you get
Free$0Light agent quota, limited model choice, unlimited Tab + inline edits
Pro$20Full quotas, frontier models (Claude Sonnet 4.6 / Opus 4.7, GPT-5.5, Gemini 3.1 Pro), free SWE-1.6, cloud agents
Max$200Everything in Pro with significantly higher daily/weekly quotas
Team$80 base + $40/seatPro features plus admin dashboard, central billing, priority support
EnterpriseCustomSSO, dedicated deployment, account management

Cognition’s own SWE models (SWE-1.5, SWE-1.6, mini variants) consume zero quota — only frontier-model calls draw down your allowance. The free tier is enough for the single first-run task in this guide.

When to reach for it

When Cursor’s agent feels slow to commit to a plan, or when you want a fresh tool to A/B against your current loop. Windsurf is a strong fit for tightly scoped multi-file edits: port one pattern across five files, add an endpoint plus its tests, or run a mechanical migration. It loses to Cursor on community size and extension count, and to Claude Code on long shell-driven terminal sessions.

Before you start

  • A real project checked out locally — not a fresh hello-world. The agent’s value only shows with real codebase context.
  • Tests and lint passing on main. Cascade amplifies the state of the repo, including breakage.
  • A Devin/Windsurf account (free tier works for the first run; Pro at $20/mo unlocks frontier models and bigger quotas).
  • A small target picked in advance: rename a function across three files, add a test file for one module, port one component to a new pattern. Not “modernize the codebase.”

Step by step

  1. Install and launch. Download from the official site. New installs arrive as Devin Desktop; if you already had Windsurf it auto-updated over the air. On first run it offers to import your VS Code settings and extensions — accept it, that saves twenty minutes.
  2. Sign in. Authenticate with your Devin/Windsurf account (managed from the vendor website). If the panel didn’t prompt you, open the command palette (Cmd/Ctrl+Shift+P) and search “Sign In.” Confirm the status bar shows your account.
  3. Open your project folder and wait for indexing. The status bar shows progress. Do not run the agent until indexing finishes, or you’ll get hallucinated file paths. If you want a quick map of an unfamiliar repo first, open a Codemap and skim the entry points.
  4. Write a rules file. Create .devin/rules/project.md at the repo root (or keep an existing .windsurfrules — both load):
# Project rules for the agent
- Language: TypeScript, strict mode on.
- Test command: `pnpm test`. Always run after edits.
- Lint command: `pnpm lint`. Fix lint errors before declaring done.
- Do not edit files under `src/generated/` — they are codegen output.
- Prefer named exports. Avoid default exports in new files.
- For React components, colocate the test as `Component.test.tsx`.
  1. Open the agent panel (right-hand side, or Cmd/Ctrl+L). Pick the model. Sensible defaults as of June 2026: Claude Sonnet 4.6 for general code, SWE-1.6 for fast mechanical edits (it costs zero quota), Claude Opus 4.7 or GPT-5.5 when you need deep reasoning over architecture, or Adaptive to let the router choose. Type one tight prompt:
Plan a rename of getUser to fetchUserProfile across src/.
List the files you will touch and the tests you will update.
Do not edit yet.
  1. Read the plan and push back. Reject out-of-scope files and flag missed test updates. Then say: Proceed with the plan, one file at a time, run tests after each file.
  2. Watch the diff as the agent works. Accept or reject per file. When tests pass and the diff matches the plan, commit.

A prompt that produces honest output

Save this as a reusable agent snippet (or a workflow) and paste it as the first message of any non-trivial session:

You are working in this repo. Before editing:
1. Read the rules in .devin/rules/ and list any rule that applies to this task.
2. List the files you plan to modify and why, in one sentence each.
3. List files you will NOT touch and why.
4. State the test command you will run and when.

Then wait for me to say "proceed". Do not write code until I do.
Never edit files under src/generated/ or vendor/.
If a step fails twice, stop and ask — do not loop.

Most Windsurf first-session regret comes from the agent skipping the planning beat. Forcing the plan first is the single highest-leverage habit.

Quality check

  • The diff matches the plan you approved. Anything beyond it is scope creep — reject and re-prompt.
  • Tests pass at the end of each file, not only at the very end. If the agent batched everything and tests fail at the end, you can’t bisect.
  • Your rules file is committed so teammates inherit the constraints.
  • The agent conversation references real symbols and files. Hallucinated names mean indexing wasn’t finished — re-index and retry.
  • The model matched the task: Sonnet 4.6 for general code, Opus 4.7 / GPT-5.5 for architecture reasoning, SWE-1.6 for boilerplate.

How to reuse this workflow

  • Save the planning prompt above as an agent snippet or a Workflow. Reuse it as the first message of every non-trivial session.
  • Treat your rules file as living memory. When the agent does the wrong thing twice, add a forbidden line. You can also ask Cascade to write a durable rule into .devin/rules/ directly.
  • Build a “always pin” list — central types, the main config, the test setup — and mention them at the top of any prompt that might touch them.
  • After a successful session, copy the agent’s final summary into your PR body. It’s usually decent boilerplate.

Common mistakes

  • Running the agent before indexing finishes. You get fake file paths and lose trust on day one.
  • Skipping the rules file because “the project is simple.” Even a ten-line rules file measurably improves output.
  • Asking for “modernize this module.” You get a 40-file diff with no way to review it. Name a small step.
  • Treating the agent like Cursor’s Composer. The shape is similar, but Windsurf commits to plans more aggressively — your prompts need tighter scopes.
  • Using a frontier model for every task. Opus 4.7 and GPT-5.5 are overkill (and slower) for boilerplate. Switch to SWE-1.6 or Sonnet 4.6 for mechanical edits — and SWE-1.6 doesn’t spend quota.
  • Accepting the whole diff without reading. Even good agents quietly edit one file you didn’t want touched.

FAQ

  • Is Windsurf still called Windsurf?: As of June 2, 2026 the editor is officially Devin Desktop (Windsurf was acquired by Cognition). It’s the same VS Code-based IDE and your old setup is fully compatible; older installs still show the Windsurf name until they update.
  • Is Windsurf better than Cursor?: Different tradeoffs. Windsurf’s agent loop feels tighter for mechanical multi-file work, and SWE-1.6 calls are free; Cursor wins on community, extensions, and rule ecosystem. Both are $20/mo for Pro — try each for a week before picking.
  • Does Windsurf work offline?: No. The agent calls remote models. Inline completion has limited local heuristics, but Cascade / Devin Local needs network access.
  • Can I use my own API key?: Yes, via BYO-key (BYOK) settings. You bypass the included quotas but pay your provider directly.
  • Why are my edits being reverted between turns?: The agent sometimes re-reads a file and overwrites unsaved changes. Save before continuing the conversation, or use the file-by-file accept flow.

Tags: #AI coding #Tutorial #Windsurf

Related Articles