Skip to main content
Toolsbase Logo

Cursor Commands & Shortcuts

Reference for Cursor editor keyboard shortcuts, @ mentions, AI features, and settings. Filter by category and copy with one click.

Last updated:

How to Use

Expand how to use
  1. 1

    Filter by category

    Switch between Shortcuts, Command Palette, AI Features, and Settings to find what you need quickly.

  2. 2

    Search details

    Use keyword search to match command names, key points, and example descriptions at once.

  3. 3

    Copy and use

    Copy commands or shortcuts with one click to use in your settings or cheat sheets.

Latest Updates

Check the latest Cursor version information

Canvases (2026-04-15)

Cursor agents can now respond with interactive canvases—durable artifacts that combine first-party components like tables, diagrams, and charts to build dashboards and custom UIs, pinned in the Agents Window side panel.

Cursor 3.1 (2026-04-13)

A minor update that refines the Agents Window with tiled layouts for parallel agent management, hold-to-speak voice input via Ctrl+M, batch STT processing, and keyboard-navigable Design Mode.

View all updates →

Shortcuts

⌘I
Toggle the Agent/side panel. Used for interacting with the AI agent.
⌘L
Toggle the side panel (Chat).
⌘K
Open Inline Edit. After selecting code, give editing instructions in natural language.
⌘.
Open the mode menu to switch between Agent / Ask / Manual / Custom Modes.
⌘/
Cycle through available AI models.
⌘⇧J
Open Cursor-specific settings.
⌘⇧P
Open the Command Palette (shared with VS Code).
⌘⇧L
Add selected code as context to Chat.
⌘⇧K
Add selected code as context to Inline Edit, or toggle focus to the Inline Edit input.
⌘⇧⌫
Cancel AI generation.
⌘↩
Context-dependent action. Chat: accept all changes. Terminal: run generated command.
⌘⌫
Reject all changes suggested by the Agent.
⌘→
Accept Tab completion suggestions one word at a time (partial accept).
⌘N
Start a new chat. Cmd R also performs the same action.
Tab
Accept Tab completion suggestion. In chat, move focus to the next message.
Escape
Reject Tab completion suggestion, or unfocus the chat input.
⇧Tab
Cycle through the main chat modes from the input box. Useful for moving between Agent, Ask, and Manual workflows.
⌘⇧Space
Toggle Voice Mode (voice input).
⌃↩
Queue a message. It will be sent automatically after the current task finishes.
⌥↩
Ask a quick question in Inline Edit without applying any changes.
⌘⌥/
Toggle AI model in chat.
⌘E
Toggle Agent layout. Switch between side panel and fullscreen Agent view.
⌘M
Toggle file reading strategies. Changes how the AI reads files for context.
⌘T
Open a new chat tab. Manage multiple chat sessions using tabs.
⌘[
Navigate to the previous chat. Browse back through your chat history.
⌘]
Navigate to the next chat. Browse forward through your chat history.
⌘⇧V
Paste clipboard content as text into the input box. Inserts directly as text instead of as a context reference.
⌃M
Press and hold to start voice input in the Agents Window. Dictation is captured while the key is held, then finalized with batch speech-to-text when released.

Command Palette

@Files & Folders

Type @ in chat input to reference specific files or folders as context.

Key points

  • Type / after a folder name to expand subfolders.
  • Navigate candidates with arrow keys; press Enter to select.

Examples

@src/components/Header.tsx
Add a specific file to AI context

@Code

Reference specific code symbols (functions, classes, etc.) as context.

Key points

  • More granular than @Files.
  • Directly specify functions or classes.

Examples

@handleSubmit
Add a specific function to context

@Docs

Reference indexed documentation. Custom URL documents can also be added.

Key points

  • In addition to built-in docs, you can add your own URLs.
  • Use the "Add new doc" option to register new documentation URLs.

Examples

@Docs → Next.js
Reference the Next.js documentation

@Git

Reference Git context such as diffs, commits, branches, and PR state directly in chat.

Key points

  • Useful when asking about recent changes or review context.
  • Lets the model reason about repository history without pasting diffs manually.

Examples

@Git → "Summarize what changed on this branch"
Ask Cursor to explain the current Git state

@Web

Pull web content into chat context for docs, references, and external research.

Key points

  • Useful for release notes, API references, and third-party documentation.
  • Use when internal project files are not enough context.

Examples

@Web https://docs.cursor.com
Bring an external documentation page into the conversation

@Cursor Rules

Reference current Cursor rules directly in chat.

Key points

  • Useful when asking the agent to follow or explain repository-specific rules.
  • Surfaces rule context without manually copying rule files into the prompt.

Examples

@Cursor Rules
Include active rule context in the current conversation

@Past Chats

Reference past chat history as context.

Key points

  • Useful for carrying over decisions and discussions from previous conversations.

Examples

@Past Chats
Reference previous chat content to continue work

/summarize

Manually compress the context window and summarize the conversation.

Key points

  • Use when context runs low in long conversations.
  • Auto-compression also occurs, but this allows explicit manual execution.

Examples

/summarize
Compress a long conversation to continue efficiently

/commit

Generate a commit message from your changes.

Key points

  • Custom command: can be defined in .cursor/commands/commit.md.
  • Can be combined with /pr.

Examples

/commit
AI analyzes changes and suggests a commit message

/pr

Generate a pull request description from your changes.

Key points

  • Custom command: can be defined in .cursor/commands/pr.md.
  • Can be used with /commit: /commit and /pr

Examples

/commit and /pr these changes to address DX-523
Create a commit and PR simultaneously

.cursor/commands/*.md

Define custom slash commands as Markdown files.

Key points

  • Project-level: .cursor/commands/*.md
  • Global: ~/.cursor/commands/*.md
  • Team: Created via Cursor Dashboard (Team/Enterprise plans).

Examples

.cursor/commands/code-review.md
Create a custom code review command

/create-rule

Slash command to auto-generate rule files in Agent chat. Creates .mdc files with proper frontmatter.

Key points

  • Auto-generates rule files under .cursor/rules/.
  • Creates files with frontmatter (alwaysApply, globs, etc.).

Examples

/create-rule
Generate a new Cursor rule file from chat

/migrate-to-skills

Built-in command to convert existing rules and slash commands to skills format (Cursor 2.4+).

Key points

  • Automatically converts rules with 'Apply Intelligently' configuration.
  • Preserves original behavior patterns when migrating slash commands.

Examples

/migrate-to-skills
Batch-convert existing rules to skill format

/worktree

Run agents in an isolated git worktree. Try changes without affecting the main branch.

Key points

  • Agent works in an independent worktree, keeping your main code safe
  • Ideal for parallel branch work and experimental changes

Examples

/worktree
Run agent in an isolated git worktree

/best-of-n

Send the same prompt to multiple AI models in parallel and compare results to pick the best one.

Key points

  • Compare outputs from multiple models simultaneously
  • Useful for comparing code generation and refactoring quality

Examples

/best-of-n
Run parallel generation across models and compare results

AI Features

Agent

Autonomous AI agent. Reads, edits, searches, and executes commands across your entire codebase.

Key points

  • Launch with Cmd I. Best for complex features and refactoring.
  • Tools: Semantic Search, file read/write, shell execution, browser, image generation, etc.
  • Checkpoints automatically save state before changes.

Examples

Cmd I → "Add authentication"
Have Agent implement a feature across multiple files

Ask

Read-only mode. Explores the codebase to answer questions without making changes.

Key points

  • Switch with Cmd . → Ask.
  • Best for learning, planning, and understanding code.
  • Only search tools available (edit tools disabled).

Examples

Cmd . → Ask → "How does this function work?"
Understand code without making changes

Manual

Manual mode. Use it when you want Cursor to pause between steps and ask before taking actions.

Key points

  • Switch via Cmd . → Manual.
  • Helpful for review-style conversations and cautious step-by-step changes.
  • Reduces autonomous actions and keeps you in the loop.

Examples

Cmd . → Manual → "First outline the change plan only"
Review the approach before implementation starts

Custom Modes

Custom Modes. Add your own task-specific modes with tailored prompts and tool access.

Key points

  • Open Cmd . to select an existing custom mode or create a new one.
  • Useful for review-only, docs-only, or team-specific workflows.
  • Each mode can define its own instructions and available tools.

Examples

Cmd . → Custom Modes → "Review"
Switch to a dedicated review mode

Tab Completion

Cursor's AI-powered completion. Displays context-aware multi-line suggestions.

Key points

  • Shows ghost text (additions) or diff popups (modifications).
  • Tab: accept. Escape: reject. Cmd →: accept one word at a time.
  • Jump in file: auto-moves to next edit location after accepting.
  • Jump across files: portal window suggests edits in other files.

Examples

Tab → Tab (jump)
Accept suggestion and auto-jump to the next edit location

Inline Edit (Cmd K)

Inline editing via Cmd K. Edit code directly with natural language instructions.

Key points

  • Select code then Cmd K to enter edit instructions.
  • Opt Return: ask a question without editing.
  • On empty files, can generate the entire file.

Examples

Cmd K → "Add TypeScript types"
Add TypeScript type annotations to selected code

Memories

Store durable preferences and project context for future agent runs.

Key points

  • Useful for coding style, recurring constraints, and preferred workflows.
  • Can be used by agents and automations to stay consistent across sessions.

Examples

Save memory: "Use pnpm in this repository"
Persist a project preference for later tasks

Parallel Agents

Run multiple Agents in parallel. Each Agent works in an isolated Git worktree.

Key points

  • Best-of-N: send the same prompt to multiple models simultaneously and compare.
  • Apply button merges worktree changes back to the main branch.
  • Up to 20 worktrees per workspace.

Examples

Launch multiple Agents → Apply best result
Compare parallel implementations and choose the best one

Checkpoints

Automatically saves Agent changes as snapshots. Can be restored at any time.

Key points

  • Auto-saved each time the Agent makes changes.
  • "Restore Checkpoint" button to revert to any point.

Examples

Restore Checkpoint
Revert Agent changes to a previous state

Review (Find Issues)

After Agent completes, analyzes diffs with a "Find Issues" pass to detect problems.

Key points

  • Review option appears automatically after Agent finishes.
  • Detects code quality, bugs, and security issues.

Examples

Find Issues
Detect issues in the Agent's changes

Bugbot

Automated pull request review assistant with issue detection and Autofix support.

Key points

  • Finds likely bugs, regressions, and quality issues in PRs.
  • Can suggest direct fixes from the review findings.

Examples

Bugbot → Autofix
Turn a Bugbot finding into an immediate fix suggestion

Terminal Cmd K

Press Cmd K in the terminal to generate commands from natural language.

Key points

  • Cmd Return: execute the generated command.
  • Escape: accept command into shell (without running).

Examples

Terminal → Cmd K → "Search logs from last 3 days"
Generate shell commands from natural language

Cloud Agents

Run agents in the cloud to automatically generate merge-ready PRs. Computer Use enables testing in isolated VMs.

Key points

  • Launch from cursor.com dashboard or via API.
  • Computer Use: browser automation, screenshots, and video recording in isolated VMs.
  • Bugbot Autofix: detects issues in PRs and auto-proposes fixes (35%+ merge rate).

Examples

cursor.com → Cloud Agents → New Agent
Launch a cloud agent to auto-generate PRs

Background Agents

Run long-lived agents asynchronously for research, migrations, and monitoring tasks.

Key points

  • Useful when a task takes too long for an interactive foreground session.
  • Pairs naturally with cloud execution and automations.

Examples

Start a background agent to investigate flaky tests
Offload a long-running task to an async agent

Automations

Always-on agents triggered by events. Runs automatically in response to GitHub, Slack, Linear, PagerDuty, and webhook events.

Key points

  • Triggers: schedule (cron), GitHub PR/push, Slack messages, Linear issues, PagerDuty incidents, webhooks.
  • Tools: open PR, comment, request reviewers, send to Slack, MCP, Memories, and more.
  • Permissions: Private / Team Visible / Team Owned.

Examples

cursor.com/automations/new
Create a new automation for event-driven tasks

Subagents

Delegate complex tasks to specialized subagents. Each runs independently with its own context window, enabling parallel execution.

Key points

  • Built-in subagents: Explore (code search), Bash (shell execution), Browser (browser control).
  • Two modes: foreground (blocks until done) and background (returns immediately).
  • Custom subagents can have dedicated prompts, tools, and models.

Examples

Agent → delegate research to subagent
Offload large codebase exploration to keep the main conversation focused

MCP Apps

MCP extension that renders interactive UI like charts, diagrams, and whiteboards inside Cursor.

Key points

  • Displays partner UIs from Amplitude, Figma, tldraw, and more directly inside Cursor.
  • MCP tools can return interactive UI alongside standard tool output.

Examples

MCP Apps → view diagram in tldraw
View interactive diagrams during a chat session

Agents Window

A new interface for running multiple agents in parallel across repos and environments: locally, in worktrees, in the cloud, and on remote SSH.

Key points

  • Open via Cmd Shift P → 'Agents Window'
  • Can be used alongside the traditional IDE view; switch back anytime.
  • Run multiple agents across repositories and environments simultaneously

Examples

Cmd Shift P → Agents Window
Open Agents Window to run multiple agents in parallel

Design Mode

Annotate and target UI elements directly in the browser within Agents Window, giving precise feedback to the agent.

Key points

  • ⌘+Shift+D: toggle Design Mode
  • Shift+drag: select an area
  • ⌘+L: add element to chat, ⌥+click: add element to input

Examples

⌘+Shift+D
Toggle Design Mode to directly target UI elements

Agent Tabs

View multiple agent chats side-by-side or in a grid layout within the editor.

Key points

  • Display multiple chats simultaneously for parallel work
  • Switch between side-by-side and grid layouts

Examples

Agent Tabs
View multiple agent chats at once in a grid

Tiled Layout

Split the Agents Window into panes so you can run and manage multiple agents side by side in parallel.

Key points

  • Split the current view into panes to manage several agents at once
  • Drag agents between tiles to rearrange them on the fly
  • Use keybindings to quickly navigate between tiles

Examples

Tiled Layout
Split the Agents Window into tiles and run multiple agents in parallel

Settings

.cursor/rules/*.md

Define project-specific AI rules as Markdown files. Version-controlled.

Key points

  • Location: .cursor/rules/*.md or .cursor/rules/*.mdc
  • Apply types: Always Apply, Apply Intelligently, specific files only, manual.
  • Use frontmatter to set alwaysApply: true or globs patterns.

Examples

.cursor/rules/coding-standards.md
Define coding standards as a rule file

User Rules

Define global rules for all projects from Cursor settings.

Key points

  • Location: Cursor Settings → Rules
  • Project rules take precedence (Team > Project > User).

Examples

Cmd Shift J → Rules
Configure global rules

AGENTS.md

AGENTS.md file in project root. A simpler alternative to .cursor/rules for rule definitions.

Key points

  • Write rules in Markdown format.
  • Functional alternative to .cursor/rules.
  • .cursorrules (legacy) is still supported.

Examples

AGENTS.md
Place AI rules at the project root

Generate Cursor Rules

Generate rule files from existing codebase conventions or prompts.

Key points

  • Useful for bootstrapping `.cursor/rules` from the current repository style.
  • Can help turn team conventions into reusable Cursor rules.

Examples

Cmd Shift P → Generate Cursor Rules
Create new Cursor rule files from repository context

Auto-Run Mode

Configure Agent's shell command auto-execution permissions.

Key points

  • Modes: Run in Sandbox / Ask Every Time / Run Everything
  • Network access: sandbox.json only / defaults included / allow all.
  • Protections: browser auto-run, file deletion, dotfile, and external file protection.

Examples

Cmd Shift J → Agents → Auto-Run
Change command auto-execution security settings

Tab Settings

Customize Tab completion behavior.

Key points

  • Partial Accepts: accept one word at a time with Cmd →.
  • Toggle suggestions in comments, whitespace-only suggestions, auto-import (TypeScript/Python).
  • Status bar: snooze, disable globally, or disable for specific file extensions.

Examples

Cmd Shift J → Tab
Open Tab completion detailed settings

.cursorignore

Specify files to exclude from AI indexing and reference. Uses .gitignore format.

Key points

  • Location: .cursorignore in project root.
  • Same pattern syntax as .gitignore.
  • Exclude sensitive files or binaries from AI.

Examples

.cursorignore → .env*
Exclude environment variable files from AI indexing

MCP Servers

Configure Model Context Protocol (MCP) servers. Add custom tools to AI.

Key points

  • Location: Cursor Settings → MCP, or .cursor/mcp.json
  • Configure MCP tool allowlists for sandbox execution.

Examples

.cursor/mcp.json
Configure project-specific MCP servers

.cursor/worktrees.json

Configure worktrees for Parallel Agents. Define setup scripts.

Key points

  • Location: .cursor/worktrees.json
  • Setting: cursor.worktreeCleanupIntervalHours (cleanup interval).
  • cursor.worktreeMaxCount: max worktrees per workspace (default 20).

Examples

.cursor/worktrees.json
Define worktree setup scripts

.cursor/skills/

Skill system that adds specialized capabilities to agents. Package domain knowledge and workflows in SKILL.md files.

Key points

  • Locations: .agents/skills/, .cursor/skills/, ~/.cursor/skills/
  • SKILL.md contains metadata (name, description) and documentation.
  • Invoke manually with /skill-name or let the agent use it automatically.

Examples

.cursor/skills/code-review/SKILL.md
Create a custom code review skill

.cursor/hooks.json

Run custom scripts before or after each stage of the agent loop. Use for security checks, auto-formatting, and auditing.

Key points

  • Locations: .cursor/hooks.json (project), ~/.cursor/hooks.json (user)
  • Events: sessionStart/End, preToolUse/postToolUse, beforeShellExecution, and more.
  • Two types: command-based (shell scripts) or prompt-based (LLM-evaluated).

Examples

.cursor/hooks.json → preToolUse
Run a security check before each tool execution

Plugins

Distributable bundles packaging rules, skills, agents, commands, MCP servers, and hooks. Shared via Cursor Marketplace.

Key points

  • Manifest: .cursor-plugin/plugin.json (name field required).
  • Published on Cursor Marketplace. Team/Enterprise can use private marketplaces.
  • All marketplace plugins undergo security review before listing.

Examples

.cursor-plugin/plugin.json
Define a custom plugin manifest

Team Rules

Organization-wide rules managed via dashboard for Teams/Enterprise plans. Take precedence over project rules.

Key points

  • Configured from the Cursor dashboard.
  • Precedence: Team Rules > Project Rules > User Rules.

Examples

cursor.com → Team Rules
Set AI rules for the entire team

cursor agent

CLI tool to launch AI agents from the terminal. Supports interactive mode, headless execution, and CI/CD integration.

Key points

  • cursor agent: start interactive session. cursor agent "prompt": start with initial instruction.
  • cursor agent ls: list past conversations. cursor agent resume: continue latest session.
  • cursor agent -c: run in cloud mode. Supports headless and CI execution.

Examples

cursor agent "Add authentication"
Launch an AI agent from CLI to execute a task

Version Updates

Major Cursor version updates and new features.

Canvases (2026-04-15)

Cursor agents can now respond with interactive canvases—durable artifacts that combine first-party components like tables, diagrams, and charts to build dashboards and custom UIs, pinned in the Agents Window side panel.

Source

  • Canvases let agents respond with interactive visual artifacts instead of plain text
  • Built-in first-party components: tables, boxes, diagrams, and charts can be composed on a single canvas
  • Seamlessly integrates with existing Cursor surfaces such as diffs and to-do lists
  • Generated canvases persist in the Agents Window side panel so you can revisit them later
  • Available in Cursor 3.1 across the Agents Window and the editor
Cursor 3.1 (2026-04-13)

A minor update that refines the Agents Window with tiled layouts for parallel agent management, hold-to-speak voice input via Ctrl+M, batch STT processing, and keyboard-navigable Design Mode.

Source

  • Tiled Layout splits the Agents Window into panes so multiple agents can run and be managed in parallel
  • Ctrl+M captures voice input while held and transcribes it with batch STT when released
  • Design Mode now supports navigating the element tree (up, down, sideways) from the keyboard
  • Search and select a branch from the empty state before launching a cloud agent
  • Jump straight from a diff to the matching line in the file, plus include/exclude filters in Search in Files
Bugbot Learned Rules & MCP Support (2026-04-08)

Bugbot now learns from pull-request feedback and turns those signals into rules, gains MCP server support for richer review context, and ships a Fix All action. Resolution rate reaches an all-time high of 78%.

Source

  • Learned Rules let Bugbot self-improve in real time from pull-request feedback
  • Bugbot MCP Support gives reviews access to MCP servers for additional context
  • Fix All applies multiple Bugbot fixes in a single operation
  • Improvements to Bugbot Autofix push the resolution rate to 78%
Cursor 3.0 (2026-04-02)

A new agent-centric interface with Agents Window, Design Mode, Agent Tabs, and /worktree and /best-of-n commands. Run agents in parallel across environments.

Source

  • Agents Window runs multiple agents in parallel across local, worktree, cloud, and remote SSH environments
  • Design Mode annotates and targets UI elements directly in the browser for precise agent feedback
  • Agent Tabs displays multiple chats side-by-side or in a grid layout within the editor
  • /worktree command for isolated git worktree execution, /best-of-n for parallel multi-model comparison
  • New Await tool for agents, enhanced screenshot-based browser automation
Self-hosted Cloud Agents (2026-03-25)

Self-hosted Cloud Agents keep your code and tool execution entirely in your own network. Full Cloud Agent capabilities with isolated VMs and plugins, without sending code externally.

Source

  • Self-hosted Cloud Agents keep code and tool execution on your own infrastructure
  • Codebase and secrets remain within your internal network
  • Same capabilities as hosted agents including isolated VMs and plugins
Composer 2 (2026-03-19)

Adds Composer 2, a new AI model with frontier-level coding performance and strong results on challenging coding tasks in CursorBench.

Source

  • New Composer 2 model delivers frontier-level coding performance
  • Strong results on challenging coding tasks measured by CursorBench benchmarks
  • Two pricing tiers: Standard ($0.50/M input, $2.50/M output) and Fast ($1.50/M input, $7.50/M output)
Marketplace Expansion (2026-03-11)

Adds more than 30 new Marketplace plugins, expanding integrations for Atlassian, Datadog, GitLab, Hugging Face, PlanetScale, and more.

Source

  • Adds 30+ new Marketplace integrations
  • Includes Atlassian, Datadog, GitLab, Hugging Face, PlanetScale, and other major services
  • Makes it easier to connect external tools and data sources from inside Cursor
Automations (2026-03-05)

Introduces always-on trigger-based agents. Cloud agents run automatically in response to GitHub, Slack, Linear, PagerDuty, and webhook events.

Source

  • Automations runs cloud agents on schedules or event triggers
  • Triggers: GitHub PR/push, Slack messages, Linear issues, PagerDuty incidents, webhooks
  • Tools: PR creation, comments, reviewer requests, Slack messages, MCP, Memories
  • Can be created in one click from Marketplace templates
JetBrains Support (2026-03-04)

Cursor is now available in IntelliJ IDEA, PyCharm, and WebStorm via Agent Client Protocol.

Source

  • Use Cursor AI features inside IntelliJ IDEA, PyCharm, and WebStorm
  • Integrated through Agent Client Protocol
  • Supports OpenAI, Anthropic, Google, and Cursor models
Cursor 2.6 (2026-03-03)

MCP Apps bring interactive charts, diagrams, and whiteboards into Cursor. Team Marketplaces allow private plugin sharing.

Source

  • MCP Apps embeds interactive UI from Amplitude, Figma, tldraw, and more inside Cursor
  • Team Marketplaces allows private plugin sharing for Teams and Enterprise plans
  • Support for parallel Debug sessions
  • Debug mode automatically removes unneeded code between turns and adjusts logging dynamically
  • Browser tool adds context menus and zoom support
Bugbot Autofix (2026-02-26)

Adds one-click autofix suggestions for issues Bugbot finds on pull requests.

Source

  • Run Autofix directly from Bugbot findings
  • Review and apply fix suggestions while staying in the PR flow
  • Cuts the back-and-forth between review and remediation
Cursor 2.5 (2026-02)

Introduces the plugin system and Cursor Marketplace. Adds async subagents and sandbox network controls.

Source

  • Plugins and Cursor Marketplace for installing and managing extensions
  • Async Subagents supports background execution and nesting of subagents
  • Long-Running Agents becomes available as a research preview
  • Sandbox Network Controls adds domain-level network access controls
  • CLI improvements: Plan Mode menu and terminal Mermaid ASCII rendering

About Cursor Commands & Shortcuts

A searchable reference covering the full surface of Cursor editor — keyboard shortcuts, AI mode switching (Agent, Ask, Manual, Custom), @ mention context syntax, slash commands, .cursorrules configuration, and MCP integration. Organized by category based on Cursor's official documentation, with version update notes included. Filter, search, and copy any command in one click without leaving your current context.

Features

  • Comprehensive coverage of shortcuts, @ mentions, AI features, and settings
  • Category filters and text search for quick access
  • One-click copy for instant reference
  • Accurate reference based on Cursor official documentation
  • Version update information included

Use Cases

  • Looking up the right keyboard shortcut (Cmd I vs Cmd K vs Cmd L) when you keep opening the wrong Cursor panel mid-coding session
  • Deciding which mode to use — Agent, Ask, Manual, or Custom — before starting a complex refactoring task across multiple files
  • Checking the correct @ mention syntax (@file, @folder, @web, @docs, @git) to give Cursor context without pasting code manually
  • Creating a team .cursorrules file and referencing this guide to ensure everyone on the project uses consistent AI behavior
  • Onboarding a VS Code user to Cursor by showing them which shortcuts carry over and which new ones (Cmd I, Cmd .) they need to learn

FAQ

Are Cursor shortcuts the same as VS Code?

Cursor is a VS Code fork, so all VS Code shortcuts work unchanged. Cursor adds its own AI shortcuts on top: Cmd I (open Agent), Cmd K (inline edit), Cmd L (open chat), and Cmd . (switch modes). Everything else behaves exactly as in VS Code.

What is the difference between Agent, Ask, Manual, and Custom Modes?

Agent autonomously reads files, writes code, and runs terminal commands. Ask is read-only — great for questions and explanations without touching files. Manual pauses for your approval between each step. Custom Modes let you define your own instruction set and tool permissions for a specific workflow (e.g., a dedicated code-review mode).

What are the Windows and Linux equivalents of Mac shortcuts?

Replace Cmd with Ctrl and Opt with Alt. For example: Cmd I → Ctrl I, Cmd K → Ctrl K, Cmd Shift P → Ctrl Shift P. All keybindings are customizable via Ctrl Shift P → 'Keyboard Shortcuts'.

What is .cursorrules and should I commit it?

.cursorrules is a project-level file where you define coding conventions, preferred libraries, and custom instructions for Cursor. Yes, commit it to your repo — every teammate will then get consistent AI suggestions without manual configuration.

How do I create custom slash commands in Cursor?

Create Markdown files in the .cursor/commands/ directory. The filename becomes the slash command name, and the file content is used as the prompt template. For user-global commands (shared across all projects), place them in ~/.cursor/commands/.

How does Cursor compare to GitHub Copilot?

Cursor's Agent mode can autonomously edit multiple files, run shell commands, and iterate based on test output — going beyond Copilot's inline completion. Copilot is available directly inside VS Code without switching editors, but Cursor's multi-file agent is significantly more powerful for complex refactoring tasks.

Related Tools

Claude Code CommandsCodex CLI CommandsClaude Code Features GuideCSS Cheat Sheet