Windsurf Keyboard Shortcuts
Windsurf is a standalone editor in its own right, not an extension bolted onto someone else's — Codeium built it as a fork of VS Code's open-source core, and the practical upshot is that opening a file, finding a symbol, or running a build command feels exactly like the VS Code you already know, with Windsurf's genuinely new territory concentrated almost entirely around Cascade, its agentic AI panel. Cascade is built around the idea of a persistent, steerable agent rather than a single request-and-response exchange — it can plan a multi-step change, propose edits across several files, and optionally run terminal commands as part of carrying out a task, with the keyboard interactions around opening Cascade, submitting a request to it, and reviewing or accepting its proposed changes forming the core of what's genuinely new to learn on top of the inherited VS Code foundation. Windsurf's Supercomplete autocomplete is the editor's other headline AI feature, distinct from Cascade's more deliberate multi-step agentic work — Supercomplete predicts your next edit inline as you type, closer in spirit to a smarter, context-aware version of traditional autocomplete than to a conversational assistant, and the acceptance/rejection keys around it matter for a very different reason than Cascade's: Supercomplete is meant to be fast and low-friction for small, continuous edits, while Cascade is meant for larger, more deliberate requests you're willing to pause and describe properly.
Cascade Ai
| Action | Windows | Mac | Description |
|---|---|---|---|
| Open the Cascade panel | Ctrl+L | Cmd+L | Opens Windsurf's Cascade sidebar, the entry point for describing a task to the agent, whether a quick question about the code or a larger multi-file change you want carried out step by step. |
| Start a new Cascade conversation | Ctrl+Shift+L | Cmd+Shift+L | Clears the current Cascade conversation and starts fresh, useful when switching to an unrelated task so earlier context doesn't continue subtly shaping how Cascade interprets your next request. |
| Accept a proposed Cascade edit | Ctrl+Enter | Cmd+Enter | Applies a proposed change Cascade has shown as a reviewable diff, committing it to the actual file, the deliberate confirmation step that keeps a multi-step agentic task from silently writing changes you haven't looked at. |
| Reject a proposed Cascade edit | Ctrl+Backspace | Cmd+Backspace | Discards a proposed Cascade change without applying it, letting you steer the agent back toward a different approach by explaining what was wrong rather than accepting an edit you're not confident in. |
| Add a file to Cascade's context | @ (inside Cascade input) | @ | Typing @ inside the Cascade input opens a fuzzy file picker for explicitly attaching a specific file to the current request, useful when you already know exactly which file is relevant rather than relying on Cascade's own automatic retrieval across the codebase. |
| Approve a Cascade-proposed terminal command | Ctrl+Enter (on the proposed command) | Cmd+Enter (on the proposed command) | Confirms a specific terminal command Cascade has proposed as part of its plan, distinct from accepting a file-edit step, letting you review the exact command before it actually runs in your project's real shell environment. |
Supercomplete
| Action | Windows | Mac | Description |
|---|---|---|---|
| Accept a Supercomplete suggestion | Tab | Tab | Commits the inline autocomplete suggestion Supercomplete has proposed at the cursor, which can span more than the current line since Supercomplete predicts likely next edits rather than only completing the current token being typed. |
| Dismiss a Supercomplete suggestion | Esc | Esc | Clears the currently shown Supercomplete suggestion without applying it, returning you to normal typing without accepting anything shown. |
Editor Navigation
| Action | Windows | Mac | Description |
|---|---|---|---|
| Quick Open (Go to File) | Ctrl+P | Cmd+P | Fuzzy-search file finder inherited unchanged from Windsurf's VS Code foundation, letting you jump to any file in the open workspace by typing a partial name match. |
| Open Command Palette | Ctrl+Shift+P | Cmd+Shift+P | Brings up the searchable list of every command the editor currently exposes by name — the same fuzzy-search-by-name interaction VS Code users already rely on, now with Cascade actions and Supercomplete settings mixed in among the inherited command set rather than living in a separate menu you'd have to hunt for. |
| Toggle integrated terminal | Ctrl+` | Cmd+` | Shows or hides the integrated terminal panel, unchanged from the underlying VS Code foundation, and also the surface Cascade uses when a task calls for running a command as part of carrying out a proposed change. |
| Switch focus between editor and Cascade panel | Ctrl+1 / Ctrl+2 | Cmd+1 / Cmd+2 | Moves keyboard focus between the main editor group and the Cascade sidebar without reaching for the mouse, useful when alternating quickly between reading a proposed diff in Cascade and jumping into the file it references to check surrounding context. |
Frequently Asked Questions
What's the actual difference between Cascade and Supercomplete?
They're built for genuinely different moments in a coding session. Supercomplete is fast, inline, continuous autocomplete that predicts your next few keystrokes or a small nearby edit as you type, meant to be accepted or dismissed in a fraction of a second without breaking your typing rhythm. Cascade is a deliberate, conversational agent you open with Ctrl/Cmd+L to describe a larger task — refactor this module, add a feature spanning several files, investigate why a test is failing — and it can plan multiple steps, propose edits across files, and run terminal commands, all with reviewable checkpoints, which is a fundamentally slower and more considered interaction than a single accepted autocomplete suggestion.
Does my existing VS Code muscle memory transfer directly to Windsurf?
For core editing and navigation, yes — because Windsurf is forked from VS Code's open-source foundation, shortcuts like Quick Open, the Command Palette, and the integrated terminal toggle work exactly as they do in stock VS Code. What's new to learn is concentrated specifically in Cascade and Supercomplete's own bindings, since those are Windsurf-specific additions layered on top of that inherited foundation rather than a change to how the base editor behaves.
If I reject a Cascade-proposed edit, does it just give up on the task?
No — rejecting a specific proposed step doesn't end the broader conversation, it gives you the opportunity to explain what was wrong or redirect the approach within the same ongoing Cascade session, similar to how you'd correct a collaborator's draft rather than restarting the whole request from nothing. Cascade can then propose a revised step based on that feedback.
Can Cascade run terminal commands on its own, or does it only propose file edits?
Cascade is capable of running terminal commands as part of carrying out a multi-step task — installing a dependency, running a test suite, checking build output — not only proposing file edits, which is part of what makes it agentic rather than a simple inline suggestion tool. As with any AI tool given real shell access, reviewing what it intends to run matters, particularly on a project with any destructive scripts available.
Why would I use the @ file reference in Cascade instead of just describing the file by name?
Typing @ and picking from the resulting fuzzy list hands Cascade an exact, resolved file rather than a plain-text description it has to interpret on its own — in a monorepo with several packages that each contain a file called index.ts or config.js, that interpretation step is exactly where an unattended agent picks the wrong one, so the small extra effort of the @ picker heads off a genuine and easy-to-miss category of misdirected edit before it ever happens.
Does starting a new Cascade conversation lose any file edits Cascade already made?
No — starting a new conversation clears the conversational context and history, not any file changes that were already applied to disk in the previous conversation. Those edits remain exactly as written; what resets is Cascade's memory of the discussion that led to them, which matters when you're pivoting to a genuinely separate task and don't want earlier context influencing how the next request gets interpreted.
Is Supercomplete's multi-line prediction something I need to review as carefully as a Cascade-proposed change?
It deserves a quick glance before accepting, but the two carry different stakes by design — Supercomplete suggestions tend to be smaller, more localized, and meant to be accepted in a rapid, low-friction rhythm as you type, while Cascade's proposed edits are shown as an explicit reviewable diff specifically because they can be larger and more consequential, spanning multiple files or including a shell command. Treating every Supercomplete acceptance with the same deliberate scrutiny as a Cascade diff would defeat the point of Supercomplete being fast, but a habit of occasionally glancing at what's actually being accepted (rather than tabbing purely on reflex) is still worth keeping.
Does Windsurf work fully offline the way a plain VS Code installation does?
The base editor inherited from VS Code's foundation works offline for ordinary editing and any extensions that don't themselves need network access, but Cascade and Supercomplete both depend on a live connection to reach the underlying AI models powering them, so those two headline features specifically require connectivity even though general file editing does not.
Why would I approve a Cascade terminal command individually instead of just letting the whole task run through?
Reviewing each proposed command separately from reviewing each proposed file edit matters because a shell command's consequences aren't always as visible as a code diff — running a test suite is low-risk and easy to review after the fact, while a command that installs a package, modifies a database, or touches files outside version control entirely can have effects a diff-based review wouldn't catch. Treating command approval as its own explicit checkpoint, rather than something that rides along automatically with accepting an edit, is the more cautious habit worth keeping until you've built specific trust in how Cascade behaves on a given project.
What's a good habit for switching focus between the editor and Cascade without losing your place?
Using the panel-focus shortcuts rather than clicking keeps your hands on the keyboard through a review cycle: read a proposed diff in Cascade, jump into the actual file to check the surrounding code it didn't show inline, then jump back to Cascade to accept or reject with feedback — a rhythm that's noticeably faster once the focus-switching keystroke is muscle memory rather than requiring a mouse movement between each of those three steps.