How to use cursor cmd k inline edit mac: Cmd+K now sends code to Agent

If you learned Cursor from an older guide, you may remember a small box that appeared over selected code when you pressed Cmd+K. That box is gone. Cursor's help page says Cmd+K used to open inline edit, and that workflow has been replaced. The replacement is Agent, the chat panel that can edit your files. This page covers the current steps and what each key does now.

What Cmd+K does now on a Mac

Select the code you want to change, then press Cmd+K. Cursor sends the selection to the Agent chat, and the lines you selected appear there as a reference. Type what should change and press Return. Cmd+L does the same job, according to Cursor's inline-edit page. On Windows and Linux the keys are Ctrl+K and Ctrl+L.

Why Cmd+K changed in Cursor

Cursor 3.0 arrived on April 2, 2026. Its changelog calls it the new Cursor interface, and it introduced the Agents Window and Design Mode. In the current interface, Agent handles the edits that the old dialog used to handle. The docs say Cmd+K was replaced, but they do not name the exact release where the old dialog stopped working. Cursor's changelog lists dates, not version numbers, so official pages alone cannot pin the change to one version.

The keys you need on a Mac

Most of the work happens with five keys. ⌘K or ⌘L sends selected code to Agent. ⌘I opens the Agent panel without a selection. Shift+Tab switches between Agent modes. Cmd+Shift+Backspace stops a response that is still running. ⌘R then ⌘S opens the shortcut list, so you can check what each key is bound to.

Cmd+K shows up twice in Cursor's shortcut reference. The list gives it as Toggle Sidepanel under General, and as Add selection to new chat under code selection. Those entries conflict with the help page, which says Cmd+K sends the selection to Agent. Treat the help page as current. If Cmd+K opens the side panel for you, your shortcut is bound differently, and you can change it in the list.

How much code to select before you press Cmd+K

The selection sets the scope of the edit. Select too little and Agent may miss the context it needs. Select too much and the diff gets long and hard to read. A good rule is the smallest block that holds the whole change, plus a few lines around it.

A single line works when the fix is local, such as a wrong comparison operator or a typo in a variable name. A whole function works when the change touches its return value or its branches. A whole file works only when the change needs the full structure. For that last case, say so in the instruction, and check every changed line in the diff.

Worked example: fixing one function with Cmd+K

Say you have a short function that crashes when the input is empty. Select the whole function. Press Cmd+K. In the Agent chat, type: return an empty list when the input is empty, and keep the rest of the logic the same. Press Return. Agent works on the lines you sent and shows its edit in the diff view. Read the change before you keep it, and check that nothing outside the function moved.

The instruction matters more than the key. A clear request gives a small diff. A vague one, such as make this better, gives Agent no target. You may get a large rewrite back, which takes longer to review and is harder to undo cleanly. Ask for one change at a time.

A second example: fixing a SQL query

Suppose a query returns duplicate rows after a join. Select the query text, press Cmd+K, and type: keep one row per order_id, and keep the same columns. Agent sees the lines you selected. Check the new query by reading the join and the grouping. Then run it against a test database before you trust the result.

Keep real customer data out of the chat. A small sample of rows usually shows the same problem. If the query needs production data to reproduce the bug, describe the shape of the data instead of pasting it.

How to write a first instruction that works

1. Say what the code should do after the change, in one plain sentence.
2. Name anything that must stay the same, such as the function name or the return type.
3. Mention the language or framework if the selection is short and unclear.
4. Ask for one change at a time, then review it before you ask for the next.

Those four habits cover most cases. If the first result misses, send a follow-up in the same chat that names the exact line that is wrong. Agent can then correct that line without touching the rest of the code.

Review the diff and reject unwanted edits

Agent shows its edits in the diff view. The docs say you review each change there and reject the ones you don't want, one at a time. They don't describe a separate accept button in the current pages, so look at the controls in the diff panel in your version. Pay the closest attention to edits outside your selection, since those are the ones that surprise people.

Before you keep anything, run through a short check. Did the function name stay the same? Did the return type change? Did any file outside your selection change? Does the code still run your tests? Each answer should be yes before you move on.

If the whole result is wrong, don't patch it by hand right away. Undo first, then send a sharper instruction. Patching a bad edit can leave you with a mix of your fix and Agent's guess, which is harder to check.

Undo an edit with Restore Checkpoint

Hover over an earlier message in the Agent chat. Click Restore Checkpoint in the bottom right corner of that message. Cursor reverts the files to that point. The docs say this reverts files only and does not remove messages, so the conversation stays visible.

If you want a shorter conversation, fork the chat from an earlier message instead. Forking suits a chat that has become noisy. Restore Checkpoint suits a case where the files are wrong. If you have your own edits in the same file, save a copy first, because the rollback reaches those files too.

Agent, Ask, Plan and Debug modes

Press Shift+Tab to cycle the modes, or use the mode picker. Each mode starts a fresh context, so details from the last mode do not carry over. Pick the mode before you type, since the mode shapes what Agent is allowed to do.

• Agent reads your code and edits files.
• Ask is read-only. It answers questions and does not edit anything.
• Plan proposes a plan and edits after you approve it.
• Debug works on a problem and can edit files.

Use Ask when you want an explanation first. Switch to Agent once you know exactly what should change. Plan helps when the change spans several parts of the code and you want to check the approach before any file changes.

Send terminal output to Agent

The old Cmd+K habit also covered the terminal. A Cursor staff member wrote on the community forum that the closest replacement is Agent. To work from terminal output, select it and press Cmd+L first, then ask your question. The same post says updating Cursor won't bring the old behavior back.

Terminal output suits error messages well. Select the lines that show the error, send them to Agent, and ask what caused it. Then check the answer against the code before you change anything.

When Cmd+K does nothing or does something else

Start with the shortcut list. Press ⌘R then ⌘S, or press ⌘⇧P and search for Keyboard Shortcuts. Look up Cmd+K and Cmd+L there. Cursor says every keybinding can be remapped in that list. Cursor's docs don't give a Cursor > Settings path for shortcuts, so use the Command Palette route rather than guessing a menu.

Also check for a clash with another app. A utility or a system shortcut can claim the same key combination before Cursor sees it. Test the key in a plain text file in Cursor. If it works there, the problem is likely the selection or the file you were in.

Mistakes people make with Cmd+K on a Mac

• Pressing Cmd+K with nothing selected. Select the code first, so Agent gets the lines you mean.
• Asking for a rewrite of a whole file when only one function needs to change.
• Accepting the result without reading the diff view, then finding an unrelated edit later.
• Expecting Restore Checkpoint to delete chat messages. It only reverts files.
• Following a tutorial that describes an inline dialog. The current docs describe Agent.
• Switching modes mid-task and expecting the earlier context to carry over. Each mode starts fresh.

Most of these come from old habits. The fix is the same each time. Select the code, say what you want, and read the diff before you keep anything.

What the official docs confirm and what they don't

The help page and the overview docs agree on the core workflow. Cmd+K sends selected code to Agent, you type the instruction, and you review the edits in the diff view. Cursor's own pages confirm those steps.

Several details are not confirmed. No Mac menu path for shortcuts appears in the docs, so the Command Palette route is the one to use. The docs also don't name the Cursor version that removed the old dialog. Cursor's changelog lists dates, not version numbers.

Cursor 3.0 came out on April 2, 2026 and introduced the Agents Window. The changelog's newest entry is dated Nov 6, 2026, and it doesn't mention Cmd+K. Check which version your install runs before you rely on any single step here.

What to do next

Try the worked example on a small function in a file you can afford to change. Press ⌘K, read the diff, and use Restore Checkpoint once so you know how undo works before you need it. Then open the shortcut list and confirm what ⌘K does on your machine.

When an instruction goes wrong, change the instruction before you change the code. A narrower request in the same chat is usually faster than a manual fix on top of a bad edit.