Cursor Keyboard Shortcuts
Cursor is built as a direct fork of VS Code, so the overwhelming majority of standard text editing, file navigation, and terminal shortcuts carry over completely unchanged — anyone fluent in VS Code can sit down in Cursor and be immediately productive for ordinary editing without relearning a single base keybinding. What's genuinely new is a dense layer of AI-specific shortcuts layered on top: inline AI editing (Cmd/Ctrl+K), a dedicated AI chat panel capable of reasoning across an entire codebase, and Tab-based multi-line AI autocomplete that goes well beyond traditional IntelliSense-style single-token suggestions into predicting whole edits several lines away from the cursor. Because Cursor inherits VS Code's keybinding engine wholesale, the modifier pattern is identical too — Ctrl does the job on Windows and Linux, Cmd takes over on Mac, and any custom keybindings a developer has already configured in VS Code can typically be imported directly into Cursor's settings without translation. For a working developer, the practical split is this: the shortcuts that make Cursor feel like Cursor rather than plain VS Code cluster into two families, editing shortcuts that act directly on code in the buffer, and chat shortcuts that open a conversational surface for reasoning about a change before it's made — knowing when to reach for which is as important as knowing the key combinations themselves.
Ai Editing
| Action | Windows | Mac | Description |
|---|---|---|---|
| Open inline AI edit (Cmd/Ctrl+K) | Ctrl+K | Cmd+K | Opens an inline AI prompt directly at the cursor or over a selection, letting you describe an edit in natural language and have the AI generate or modify code in place, Cursor's signature feature distinguishing it from a stock VS Code installation. |
| Accept AI suggestion (Tab) | Tab | Tab | Commits whatever autocomplete suggestion is currently on screen — potentially several lines or a chain of related edits across the file thanks to Cursor's 'Tab, tab, tab' prediction flow, well past what a traditional single-token autocomplete ever offers. |
| Reject AI suggestion | Esc | Esc | Dismisses the currently shown AI suggestion without applying it, returning focus to normal typing, the safety valve that keeps aggressive multi-line predictions from ever being applied against your will. |
| Generate new code block from prompt | Ctrl+K (on empty line) | Cmd+K | Using the same inline-edit shortcut on an empty line or new file prompts the AI to generate an entirely new code block from a natural-language description rather than editing existing code. |
| Accept all changes in a multi-file edit | Ctrl+Enter | Cmd+Enter | When an AI-proposed change spans several files at once, this applies every proposed edit across all of them in a single action rather than reviewing and accepting file by file, meant for larger, already-reviewed multi-file refactors. |
| Jump to next predicted edit location | Ctrl+Shift+Enter | Cmd+Shift+Enter | Moves the cursor directly to the next location Cursor's model predicts also needs editing as a consequence of the change just made, part of the chained multi-location prediction flow rather than a simple single-suggestion accept. |
Ai Chat
| Action | Windows | Mac | Description |
|---|---|---|---|
| Open AI Chat panel | Ctrl+L | Cmd+L | Opens Cursor's dedicated AI Chat sidebar panel for a longer-form conversational interaction with the AI, including questions about the codebase, generating larger multi-file changes, or general coding assistance beyond a single inline edit. |
| Add selected code to Chat context | Ctrl+Shift+L | Cmd+Shift+L | Adds the currently selected code as explicit context for the next Chat message, ensuring the AI's response is grounded in that specific code rather than needing to describe or re-paste it manually into the chat. |
| Start new Chat conversation | Ctrl+N (within Chat panel) | Cmd+N | Starts a fresh Chat conversation, clearing previous conversational context, useful when switching to an unrelated task where carrying over the prior conversation's context isn't relevant or could confuse the AI's responses. |
| Toggle Agent (autonomous) mode | Ctrl+I | Cmd+I | Switches the Chat/Composer panel into Agent mode, where the AI can autonomously search the codebase, run terminal commands, and make multi-step edits toward a goal rather than waiting for a turn-by-turn conversational exchange. |
| Reference a specific file in Chat (@ symbol) | @ (inside Chat input) | @ | Typing @ inside the Chat input opens a fuzzy file/symbol picker for explicitly pulling a specific file, function, or documentation source into the conversation's context, more targeted than relying on the AI's own automatic codebase retrieval. |
Editor Navigation
| Action | Windows | Mac | Description |
|---|---|---|---|
| Quick Open (Go to File) | Ctrl+P | Cmd+P | Brings up the fuzzy-match file finder that resolves a partial typed name into a jump target, carried over unmodified from VS Code since Cursor is built on the same editor core. |
| Open Command Palette | Ctrl+Shift+P | Cmd+Shift+P | Opens the Command Palette for running any available editor command by name, inherited unchanged from VS Code, now also surfacing Cursor-specific AI commands alongside the standard VS Code command set. |
| Go to Definition | F12 | F12 | Follows the symbol under the cursor to its definition, inherited straight from VS Code's underlying editor without any Cursor-specific modification. |
| Go to Symbol in File | Ctrl+Shift+O | Cmd+Shift+O | Opens a fuzzy list of every function, class, and variable declared in the current file for jumping straight to it, standard VS Code navigation inherited unchanged and just as useful in Cursor for orienting inside a large AI-generated file. |
File Management
| Action | Windows | Mac | Description |
|---|---|---|---|
| Toggle integrated terminal | Ctrl+` | Cmd+` | Shows or hides the integrated terminal panel, identical to VS Code's own terminal toggle. |
| Save file | Ctrl+S | Cmd+S | Saves the currently active file, standard behavior unchanged from VS Code. |
| New file | Ctrl+N | Cmd+N | Creates a new untitled file in the editor, standard VS Code behavior that Cursor leaves completely untouched. |
Frequently Asked Questions
Do all my existing VS Code keyboard shortcuts and extensions still work in Cursor?
Yes, generally — because Cursor is a direct fork of VS Code's open-source codebase, it shares the same underlying keybinding system and extension API compatibility, meaning the vast majority of VS Code shortcuts, themes, and extensions work in Cursor without modification. Cursor specifically adds its AI features as new capabilities layered on top rather than replacing or restructuring VS Code's existing shortcut system, and Cursor even offers a one-click import of your existing VS Code settings, keybindings, and extensions during first launch.
What's the practical difference between inline edit (Cmd/Ctrl+K) and the Chat panel (Cmd/Ctrl+L)?
Inline edit is scoped and immediate — you select code or place your cursor, describe the change, and the AI edits directly in place at that location, suited for focused, contained changes. Chat is a broader, more conversational interface better suited for longer discussions, questions about how the broader codebase works, or requests that might span multiple files, where you want to see the AI's reasoning and iterate through conversation rather than a single direct in-place edit.
Why does Tab sometimes suggest a multi-line or multi-location edit instead of just completing the current word?
Because it's driven by a full language model rather than a token-matching engine, Cursor doesn't just guess the rest of the identifier you're typing — it can propose whole blocks spanning several lines, and it often notices that accepting one change implies a related change nearby, surfacing that as a second suggestion the moment you accept the first. Users have nicknamed the resulting rhythm 'Tab, tab, tab' since a single edit intention can cascade into several accepted suggestions in quick succession, with Ctrl/Cmd+Shift+Enter available to jump straight to wherever the next predicted edit lives if it isn't already on screen.
What is Agent mode and how is it different from a normal Chat conversation?
A standard Chat conversation is turn-based — you ask, the AI answers or proposes a change, and you decide what to do next. Agent mode (Cmd/Ctrl+I) instead lets the AI work more autonomously toward a stated goal: it can search across the codebase on its own, run terminal commands, read the results, and make a sequence of edits across multiple files without you manually approving each individual step, checking back in with you at defined checkpoints or once the task is complete rather than after every single micro-action.
Does using the @ symbol in Chat actually change what code the AI sees?
Yes, meaningfully. Without an explicit @ reference, Cursor's Chat relies on its own automatic retrieval to decide what parts of your codebase might be relevant to a question, which is often good but not guaranteed to grab the exact file or function you're thinking of. Typing @ and picking a specific file, folder, or documentation source forces that content into the AI's context directly, which is the more reliable approach any time you already know exactly which code the question or request is about.
Can I use Cursor's AI features while offline?
No — Cursor's AI features (inline edit, Chat, Tab autocomplete, and Agent mode) all depend on a network connection to reach the underlying language models, whether Cursor's own hosted models or a connected third-party API key. The base editor itself, being a VS Code fork, works completely offline for ordinary file editing, navigation, and any extensions that don't themselves require network access — it's specifically the AI layer that requires connectivity.
Is it safe to let Accept All Changes apply an edit across many files at once?
It's safe in the sense that the changes are visible as a diff before you commit to Accept All, but it does trade per-file review for speed. Most experienced Cursor users reserve Accept All for cases where they've already skimmed the proposed diff overview and trust the scope of the change, reserving file-by-file review for larger, higher-stakes refactors touching code they're less familiar with or that lacks solid test coverage to catch a mistake.