How do I use Cmd+I in Windsurf for inline refactors and follow-up edits in the same file?

Inline refactors are where Windsurf really feels like an extension of your hands. Cmd+I lets you grab a chunk of code, describe what you want in plain English, and have Cascade rewrite it in place—then keep iterating with follow-up edits in the same file until it’s exactly right.

Quick Answer: In Windsurf, Cmd+I opens Cascade directly on the selected code. You highlight some code, hit Cmd+I, describe the refactor (e.g., “convert to async/await and add error handling”), review the proposed inline change, and accept or tweak it. You can then run Cmd+I again on the updated code for follow-up edits without ever leaving the file.

The Quick Overview

What It Is: Cmd+I is Windsurf’s in-line command surface: a way to run Cascade on specific code selections for refactors, fixes, and rewrites that show up directly in your editor.
Who It Is For: Developers who want to refactor faster, keep context in their file, and avoid bouncing to a separate chat window to explain the same intent again and again.
Core Problem Solved: Cmd+I eliminates the friction of context-switching and manual, multi-step refactors by letting you drive nuanced edits with natural language, right where the code lives.

How It Works

Cmd+I connects Cascade’s “flow-aware” reasoning to the literal text under your cursor. Instead of pasting code into chat, you:

Select a function, block, or file region.
Press Cmd+I.
Describe the change you want.
See a proposed diff inline.
Accept, edit, or undo.

Because Cascade is built around full contextual awareness (edits, conversation, terminal commands, clipboard, etc.), it doesn’t just look at your selection. It can use nearby code, other files, and your recent actions to make refactors that actually fit your codebase.

Here’s the basic flow:

Target the code you want refined:
Highlight the function, class, or block you want to change. No selection? Cascade will scope to the logical unit around your cursor.
Trigger Cmd+I and describe your refactor:
Press Cmd+I in the editor. A small inline command box appears. Type a natural-language instruction like “extract a reusable hook,” “make this function pure and add JSDoc,” or “optimize this query but keep behavior identical.”
Review the inline proposal and iterate:
Cascade generates a new version in place. You review the changes, accept them, adjust anything by hand, and—if you want to take it further—run Cmd+I again on the updated code for follow-up edits in the same file.

Phase-by-Phase: Inline Refactors with Cmd+I

1. Select and Scope (PHASE_1)

You’re in the Windsurf Editor, inside your repo.

Place your cursor in the code you want to refactor, or select a region (for multi-line refactors, always select).
Think of Cmd+I as “do something smart to this.” The tighter your selection, the more precise the edit.

Examples of good selections:

A single function to convert to async/await.
A React component to split into presentational + container components.
A complex conditional block to simplify and document.

2. Command in Natural Language (PHASE_2)

Press Cmd+I in the editor.

A command input appears inline, anchored to your selection. This is Cascade’s in-line command surface.

You can now describe the desired refactor like you would to a senior teammate:

“Refactor to remove duplication and extract helper functions.”
“Convert this callback hell to async/await and handle errors with a typed Result.”
“Make this component follow idiomatic Next.js patterns and add prop type safety.”

Because Cascade is context-aware, you don’t need to re-explain the whole file. It sees the selection, surrounding code, and broader repo context.

3. Review, Apply, and Follow Up (PHASE_3)

Cascade proposes edits directly in the file:

You’ll see the new code inline, replacing your selection or updating the block.
If your linters are wired into Windsurf, Cascade will aim to generate lint-clean code—and in many cases auto-fix lint errors it introduced.

From here you stay in the same file, in flow:

Accept the change if it looks good.
Tweak manually if you want to adjust naming, structure, or comments.
Run Cmd+I again on the updated code for follow-up edits:
- “Add unit tests for this function below.”
- “Inline this helper into the call sites.”
- “Add JSDoc comments describing inputs and outputs.”
- “Make this generic and export it to a shared utils file.”

Each time, you’re using Cmd+I as a tight, iterative loop: select → describe → review → refine, all in one place.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Inline Command (Cmd+I)	Opens Cascade on the selected code and applies natural language refactors.	Fast, targeted refactors without leaving your file.
Follow-up Inline Edits	Lets you repeatedly use Cmd+I on the same area for iterative improvements.	Smooth, multi-step refactors that stay in sync with your flow.
Context-Powered Refactors	Uses full codebase and recent actions, not just the selection, to shape edits.	Refactors that respect patterns, lint rules, and architecture.

Ideal Use Cases

Best for iterative refactors in the same file: Because Cmd+I lets you make a series of small, scoped changes—rename, simplify, document—without jumping to a separate chat or tool.
Best for quick “clean this up” passes: Because you can point Cascade at a messy function or component, say “make this readable, document edge cases, keep behavior the same,” and review a concrete, inline proposal.

Limitations & Considerations

Not a whole-repo migration button: Cmd+I is optimized for scoped, inline changes. For large cross-file or project-wide refactors, use Cascade in the side panel plus repo-wide context, then validate diffs. You can still use Cmd+I for final cleanups in key files.
Human-in-the-loop is essential: Inline refactors are powerful, but they’re not autonomous. Always review the proposed changes and run tests—especially around critical logic, performance-sensitive paths, or security code.

Pricing & Plans

Cmd+I inline refactors live inside the Windsurf Editor, which is available across Windsurf plans. All plans give you access to Cascade and Tab in the editor, with different limits and admin features at the team and enterprise tiers.

Teams / Pro-style plans: Best for individual developers or small teams who want full inline Cmd+I refactors, Tab-powered workflows, and a flow-state coding experience on shared repos.
Enterprise plans: Best for organizations that need everything above plus SSO, RBAC, centralized billing, admin analytics, and governed deployments (Hybrid or Self-hosted) while their developers still get Cmd+I and Cascade in the editor.

For detailed, current pricing and plan breakdowns, check Windsurf’s site or talk to sales.

Frequently Asked Questions

How is Cmd+I different from just using autocomplete or Supercomplete?

Short Answer: Cmd+I is for commands and refactors; autocomplete is for typing faster.

Details:
Tab-based autocomplete (including Supercomplete) is about predictive code suggestions as you type—line-by-line or token-by-token. Cmd+I, by contrast, is a deliberate inline command: you select code, press Cmd+I, and ask Cascade to perform an operation (refactor, rewrite, document, add tests, etc.) on that selection. Cascade then returns a coherent, multi-line edit that can span function bodies or entire components. In practice, you’ll often:

Use Cmd+I to reshape or improve a block of code.
Use Tab to accept smaller, follow-up suggestions (like imports via Tab to Import) while you finalize the refactor.

Can I use Cmd+I in the terminal too, or only for code?

Short Answer: Cmd+I works both in the editor and in the terminal, but the behavior is tuned to each surface.

Details:
In the editor, Cmd+I is your inline refactor surface: it acts on selected code and returns a proposed code change. In the terminal, Cmd+I lets you type natural-language instructions like “run tests for this package” or “start the dev server,” which Cascade turns into shell commands. You still approve commands before they run (unless you opt into more automated workflows like Turbo mode). This keeps the agent’s power high but prevents surprise side effects. Many teams use both patterns together: inline refactors with Cmd+I in files, and then Cmd+I in terminal to run the relevant tests or build commands to validate those changes.

Summary

Cmd+I in Windsurf is your in-flow refactor lever: highlight code, describe the change, and let Cascade propose an inline edit you can inspect and refine. Because it understands your broader context—your file, your repo, your recent actions—it produces refactors that fit your patterns instead of generic rewrites. And because you can repeatedly run Cmd+I on the same file for follow-up edits, you get a tight loop for polishing code without ever leaving the editor.

Next Step

Get Started