Cursor's Four Modes

Cursor has "three and a half" modes — and each one is the right tool for a different job. Mixing them up is one of the biggest sources of frustration for new users.

The Four Modes at a Glance

Mode	Shortcut	What It Does
Inline Edit	Cmd/Ctrl+K	Edit a specific selection, right in the file
Agent	Cmd/Ctrl+L → Agent tab	Multi-file, multi-step tasks
Tab Completion	(automatic)	Ghost-text autocomplete as you type
Ask	Cmd/Ctrl+L → Ask tab	Questions about code, no changes made

Inline Edit (Cmd+K)

Inline edit is the most surgical mode. Select some code, hit Cmd+K, write what you want to change, and Cursor shows you a diff inline. Accept or reject.

When to use it:

You're staring at a specific function that needs changing
You want a targeted refactor of 5–50 lines
You want full control over exactly what changes

Example: you have a function that's 30 lines long and harder to read than it should be.

Plain text

Select the function
Cmd+K
"Refactor this into smaller, well-named helper functions"
Review the diff — accept, reject, or ask for changes

The diff is shown right in the file. Green = added, red = removed. You're in control of what gets applied.

Keyboard shortcuts in the diff view:

Tab — accept all changes
Escape — reject all changes
Cmd+Y / Cmd+N — accept / reject line by line

Agent Mode (Cmd+L → Agent)

Agent mode is where Cursor gets powerful — and where it gets dangerous if you're not paying attention.

The agent can:

Read any file in your project
Write to any file
Run terminal commands
Follow a chain of reasoning across multiple steps

When to use it:

A task that touches more than one file
You want Cursor to figure out what files are relevant
You're okay watching what it does and stepping in if needed

Example workflow:

Plain text

You: "The UserCard component needs to show the user's subscription tier.
     The tier data comes from the /api/users endpoint.
     Add it to the component."

Cursor: [reads UserCard.tsx, reads api/users.ts, checks the types,
         updates the component, updates the type definitions]

You: [review each file change in the diff panel, accept or reject]

The key discipline: watch what it's doing. Don't queue up five more requests while the agent is running. Catch mistakes early. If it starts going the wrong direction, stop it.

The "Follow the Problem" Pattern

One of the best agent mode habits: when a TypeScript error or test failure appears in the output, you can say "fix this" and the agent will follow the error into whatever file it lives in, fix it, and check if it created new errors.

This is the loop:

Plain text

Make a change
TypeScript error appears in the terminal
"Fix the TypeScript error"
Agent goes to the right file, fixes it
Check if new errors appeared
Repeat until clean

The agent can see the terminal output. Use that feedback loop — don't fix errors yourself unless it takes more than one or two iterations.

Model Selection in Agent Mode

The model picker appears at the top of the chat. You can change it mid-conversation.

A practical pattern: start with Sonnet (fast, affordable) for the implementation, then switch to Opus if you hit something it can't figure out. Don't use Opus for everything — the quality difference on routine tasks doesn't justify the cost difference.

Tab Completion

Tab completion is the "half mode" — it's always on in the background. As you type, Cursor suggests what comes next. Hit Tab to accept, Escape to dismiss.

What makes it feel different from normal autocomplete:

It predicts entire blocks, not just the next word
It uses the surrounding code to suggest what fits
After you accept a change in another part of the file, it'll predict what else probably needs to change

The move: after you manually edit something, pause. Cursor's tab completion often already knows what comes next. Don't type it — Tab.

A specific pattern: edit a function signature. Stop. Tab completion will predict the updated callers. Edit a type. Stop. Tab completion will update the related code.

Ask Mode (Cmd+L → Ask)

Ask mode is a conversation with no side effects. The AI reads your code, but doesn't change it.

When to use it:

"What does this function actually do?"
"Is there a bug in this logic?"
"Why might this be slow?"
"What would happen if I changed X to Y?"

This is underused. Before changing code you don't fully understand, ask about it first. It's faster than reading docs, and it references your actual code rather than giving generic answers.

Example:

Plain text

You: @UserCard.tsx "This component re-renders more than I expect.
     What's causing it?"

Cursor: [explains which props trigger re-renders, why the
         useEffect dependency array might be causing extra runs,
         suggests what to check]

You get the analysis without any code changes. Then you decide what to do about it.

Using Ask for code review:

Plain text

You: @src/api/payments.ts "Review this for potential security issues.
     Don't fix anything — just tell me what you see."

Cursor: [lists concerns: missing input validation on line 23,
         potential SQL injection vector on line 47,
         authorization check missing on line 61]

Ask → understand → then decide if/how to fix.

Choosing the Right Mode

Plain text

"I need to change this one function"        → Inline Edit (Cmd+K)
"I need to build a feature across files"    → Agent mode
"I want to understand this code"            → Ask mode
"I'm just writing and want suggestions"     → Tab completion (already on)

The mental model: how much control do you want? Inline edit = maximum control. Agent mode = maximum delegation. Ask = zero changes. Tab = passive.

Mixing them up doesn't break anything, but it does waste time. Using agent mode for a one-function change is overkill. Using inline edit for a 12-file refactor is pain.