AI / Cheatsheet
Cursor shortcuts, rules, and context controls worth memorizing
Cursor rewards muscle memory more than any other AI editor, because its whole pitch is a tighter loop. This reference collects the keybindings that matter, the @ mentions that decide what the model sees, the rules files that stop you repeating yourself, and how agent mode and plan mode actually differ.
About 8 min read. Shortcuts and rule formats checked against cursor.com documentation in August 2026.
Opening panels and switching modes
Mac bindings are shown. On Windows and Linux substitute Ctrl for Cmd and Alt for Opt throughout this page.
| Shortcut | What it does |
|---|---|
| Cmd I | Toggle the sidepanel, which is where the Agent lives. The single binding to learn first. |
| Cmd L | Also toggles the sidepanel, unless you have bound it to a specific mode. |
| Cmd E | Toggle the Agent layout, which gives the agent more of the window. |
| Shift Tab | Rotate between Agent modes without touching the mouse. Learn this one second. |
| Cmd . | Open the mode menu directly. |
| Cmd / | Loop through the available AI models. |
| Cmd Opt / | Open the model toggle to pick one explicitly. |
| Cmd Shift J | Cursor settings, including models, rules, and indexing. |
| Cmd , | General editor settings, inherited from VS Code. |
| Cmd Shift P | Command palette. Every VS Code command you already know still works. |
| Cmd Shift Space | Toggle Voice Mode. |
Gotcha: Cursor is a VS Code fork, so your existing keymap, extensions, and settings mostly transfer. The VS Code shortcuts cheatsheet still applies to everything that is not AI-specific.
Driving the agent chat
The distinction between nudging, queuing, and force-sending is the difference between a productive session and constantly interrupting your own agent.
| Shortcut | What it does |
|---|---|
| Return | Nudge. The default send behavior. |
| Ctrl Return | Queue the message to run after the current turn, instead of interrupting it. |
| Cmd Return | While typing, force-send immediately and interrupt whatever is running. |
| Cmd Shift Backspace | Cancel the generation in progress. |
| Cmd Return | With suggested changes on screen, accept all of them. |
| Cmd Backspace | Reject all suggested changes. |
| Tab | Cycle to the next message in the thread. |
| Cmd N or Cmd R | Start a new chat. Do this per task, not per day. |
| Cmd T | New chat tab, so two threads can run side by side. |
| Cmd [ and Cmd ] | Previous and next chat. |
| Cmd W | Close the current chat. |
| Escape | Unfocus the input field and return to the editor. |
Gotcha: Cmd+Return means three different things depending on what is focused - force-send while typing, accept-all when changes are shown, and search-the-codebase from the chat input. Read the screen before you reflex it.
Inline edit, Tab, and the terminal
Cmd+K is the underrated one. For a change confined to a selection it beats the agent every time, because there is no planning round trip and no chance of it touching another file.
| Shortcut | Context and effect |
|---|---|
| Cmd K | Editor: open inline edit on the current selection or line. |
| Cmd Shift K | Toggle focus into and out of the inline edit input. |
| Return | Submit the inline edit. |
| Cmd Shift Backspace | Cancel the inline edit. |
| Opt Return | Ask a quick question about the selection instead of editing it. |
| Tab | Accept the Tab suggestion, including a multi-line edit or a jump to the next edit location. |
| Cmd Right Arrow | Accept only the next word of a suggestion. The escape hatch when Tab is 80 percent right. |
| Cmd K | Terminal: open the terminal prompt bar and describe a command in English. |
| Cmd Return | Terminal: run the generated command. |
| Escape | Terminal: accept the command into the prompt without running it. Use this one. |
Context controls: deciding what the model sees
Cursor indexes your codebase and the agent can go find files itself, but a named reference beats a search every time - it is faster, cheaper, and removes the chance of it reading a file that has been dead for a year.
| Shortcut or symbol | What it adds |
|---|---|
| @ | Open the mention autocomplete listing every context source your install offers. |
| / | Shortcut commands inside the chat input. |
| @Files and @Folders | Include specific files or whole folders. After selecting a folder, type / to navigate deeper. |
| @Terminals | Attach terminal output. The fastest way to hand over a stack trace. |
| @Chats | Pull context forward from a previous conversation without reopening it. |
| @Commit | Attach the diff of your working state, so the agent reviews what you actually changed. |
| @Branch | Attach the full diff of your branch against main. The pull request view, as context. |
| @Browser | Attach context from the built-in browser, including what the running app looks like. |
| Cmd Shift L | Add the current code selection to the chat as context. |
| Cmd L | Add the selection to a brand-new chat. |
| Cmd Shift K | Add the selection to an inline edit instead. |
| Cmd V | With code or a log on the clipboard, add it as context. Cmd Shift V pastes it as plain input text. |
| Cmd M | Toggle file reading strategies, which changes how aggressively the agent loads whole files. |
| Cmd Return | From the chat input, search the codebase. |
Gotcha: @ mentions are for when you already know which files matter. If you genuinely do not, let the agent search - forcing it to work from the wrong four files is worse than letting it read ten.
Rules files: teaching Cursor your conventions
Rules are the highest-leverage configuration in Cursor. Anything you correct twice belongs in one, and path-scoped rules keep backend conventions out of context during frontend work.
| File or field | Behavior |
|---|---|
| .cursor/rules/*.mdc | Project rules. Markdown with frontmatter, committed to version control. Plain .md files in this directory are ignored. |
| alwaysApply: true | Load this rule into every chat session, unconditionally. |
| description: "..." | Let the agent decide when the rule is relevant. Write it as a trigger condition, not a summary. |
| globs: ["src/api/**/*.ts"] | Apply only when files matching these patterns are in play. |
| @rule-name | Manual invocation. A rule with no alwaysApply, description, or globs only loads when you mention it. |
| AGENTS.md | Plain markdown, no frontmatter, read directly by Cursor. The portable option other agents also read. |
| Nested AGENTS.md | A subdirectory can carry its own AGENTS.md for instructions scoped to that area. |
| User Rules | Your global preferences, applied across every project on your machine. Set in Cursor settings. |
| Team Rules | Organization-wide rules on Team and Enterprise plans. They take precedence in the hierarchy. |
A path-scoped project rule looks like this:
---
description: API route conventions
globs:
- "src/api/**/*.ts"
alwaysApply: false
---
- Every endpoint validates its input with Zod before touching the database.
- Use the shared `apiError()` helper; never return a bare 500.
- Queries go through Drizzle. No raw SQL in a route handler.Gotcha: if your repo also needs to work with Claude Code, put the shared conventions in AGENTS.md and add a CLAUDE.md that imports it with @AGENTS.md. One source of truth, both agents read it. The workflow guide covers what belongs in that file.
Agent mode, plan mode, and checkpoints
The Agent is the system that searches your codebase, edits files, runs terminal commands, drives the built-in browser, and completes multi-step tasks. The model it runs on is a separate choice.
Agent mode
The default. Jump straight to implementation, which is right for a quick change or a task you have done twenty times. The agent reads and edits files, runs commands, watches their output, and can take screenshots of the running app to verify a visual change.
While it works you can keep typing. Return queues a follow-up to run after the current turn; Cmd+Return sends immediately and interrupts. Queuing is almost always what you want.
Plan mode
Creates a detailed implementation plan before writing any code. It researches the codebase, asks clarifying questions, and produces a plan you can edit before anything is built. Switch with the mode picker or Shift+Tab.
Use it for anything touching more than three files. Rejecting a bad plan costs a minute; rejecting a bad implementation costs an afternoon and leaves half-applied edits behind.
Checkpoints
Cursor snapshots your codebase during an agent session, automatically before major changes, so you can preview and restore an earlier state when the agent heads somewhere you did not want. They are local and completely separate from git.
Treat them as an undo button, not as version control. Commit at real boundaries anyway - see the Git cheatsheet.
Models and Composer
Cursor exposes the frontier models plus Composer, its own in-house agentic coding model available only inside Cursor and tuned for low-latency loops rather than peak reasoning. Auto mode picks for you and does not draw down your credit pool; selecting a premium model manually does.
Practical rule: leave it on Auto for routine work, switch to a frontier model deliberately for the task that actually needs it, and check how the models compare before assuming the expensive one wins.
Gotcha: pricing is a dollar-denominated credit pool, so a week of heavy agent use on a premium model can exhaust a Pro plan well before the month ends. Auto mode and Composer exist partly to keep that from happening.
Keep going
Shortcuts do not make the output correct. The AI-assisted development workflow guide covers spec-first prompting, CI guardrails, and how to review code you did not write. To connect Cursor to your issue tracker or database, read the Model Context Protocol explainer.
Comparing before you commit a subscription: Cursor vs GitHub Copilot and Claude Code vs Cursor, plus the full assistant field guide. Official documentation is at cursor.com/docs.