20 Cursor Shortcuts and Hidden Settings for Faster Coding

Most people install Cursor, accept a few autocompletions, open the chat once or twice, and call it a day. That is coding with the handbrake on. Cursor is a full AI development environment built on top of VS Code, and the developers who move fastest are not typing faster. They are using a small set of shortcuts, context tricks, and settings that most users never find.

This guide walks you through 20 of them in the order you would actually adopt them, starting with the AI shortcuts you use every minute and building up to the hidden settings that change how Cursor behaves across your whole project. Each one comes with the exact keys for Mac and Windows or Linux, a real situation where it earns its place, and a tip or gotcha so you get it right the first time. Follow along inside your own editor and you will feel the difference before you reach the end.

What are the most useful Cursor shortcuts?

The four you cannot live without are Cmd+K for inline edits, Cmd+L for chat, Cmd+I for the agent, and Tab to accept AI predictions. On Windows and Linux, swap Cmd for Ctrl. Beyond those four, the biggest speed gains come from Cursor's @ context system and from Project Rules, both covered in detail below. Every shortcut here is remappable, so treat the keys as defaults, not law.

A quick note on keys before we start: Cursor uses Cmd on macOS and Ctrl on Windows and Linux, and Opt on macOS maps to Alt elsewhere. Where a binding differs, it is spelled out.

The core AI shortcuts you will use every minute

These are the daily drivers. Learn these four or five and you are already ahead of most Cursor users.

1. Accept AI predictions and jump ahead with Tab

Cursor Tab is the always-on prediction engine, and it does more than finish the current line. As you edit, Cursor predicts your next change and shows it as ghost text, sometimes several lines away from your cursor. Press Tab to accept, and if the suggested edit is elsewhere in the file, Tab first jumps your cursor there, then accepts on the next press.

How to use it: just start typing or editing. When grey ghost text appears, press Tab to accept it or keep typing to ignore it. Press Esc to dismiss a suggestion.

Real use: rename a variable in one place and Cursor often predicts the same rename across the rest of the function. Tab through them instead of doing a manual find and replace.

Tip: trust Tab more than feels natural at first. It reads your recent edits, so accepting and then adjusting is usually faster than typing from scratch. If suggestions stop appearing, check that Cursor Tab is enabled in settings and that the file type is not excluded.

2. Make surgical edits with Cmd+K

Cmd+K (Ctrl+K) opens the inline prompt bar right where your cursor is. It is for precise, in-place changes when you already know what needs to happen and where.

Step by step: select a block of code, press Cmd/Ctrl+K, type an instruction in plain English like "add error handling and log failures", then review the diff and accept it. With nothing selected, Cmd/Ctrl+K generates new code at the cursor instead.

Real use: you spot a function missing input validation. Select it, Cmd/Ctrl+K, "validate the email and throw on invalid input", done, without opening a chat panel or losing your place.

Tip: keep Cmd/Ctrl+K prompts small and specific. It shines at surgical work. For anything spanning several files, reach for the agent in tip 6 instead.

3. Generate terminal commands with Cmd+K in the terminal

The same shortcut behaves differently in the integrated terminal. Press Cmd/Ctrl+K in the terminal and you get an AI command bar that turns a description into a shell command.

Step by step: open the terminal, press Cmd/Ctrl+K, type something like "find all TypeScript files changed in the last week", and Cursor drafts the command for you to run or edit.

Real use: you never remember the exact find, git, or ffmpeg flags. Describe the outcome and let Cursor assemble the command. It is a quiet time saver that most people never discover because they only ever press Cmd/Ctrl+K inside a file.

4. Ask questions in chat with Cmd+L

Cmd+L (Ctrl+L) opens the chat side panel, Cursor's space for questions, explanations, and back-and-forth thinking. It is read-and-discuss, not surgical editing.

Step by step: select code, press Cmd/Ctrl+L, and the selection drops into a new chat as context. Then ask your question, for example "why does this hook re-render twice?"

Real use: you inherit an unfamiliar module. Select it, Cmd/Ctrl+L, "explain what this file does and how it is used", and you get a walkthrough without leaving the editor.

Tip: use Cmd/Ctrl+L for understanding and planning, and Cmd/Ctrl+K for changing. Matching the tool to the task is the single biggest habit that separates fast Cursor users from slow ones.

5. Add code to the current chat with Cmd+Shift+L

Where Cmd/Ctrl+L starts a fresh chat with your selection, Cmd+Shift+L (Ctrl+Shift+L) adds the selected code to the chat you already have open. This is how you build up rich context across several files before asking for anything.

Step by step: open a chat, then move around your project selecting the relevant pieces, pressing Cmd/Ctrl+Shift+L on each to stack them into the same conversation. Once the context is complete, ask your question or request the change.

Real use: a bug spans a component, its hook, and an API route. Add all three with Cmd/Ctrl+Shift+L, then ask Cursor to trace the data flow. It reasons across the whole set instead of guessing from one file.

6. Run multi-file work with the agent using Cmd+I

Cmd+I (Ctrl+I) opens the Agent, Cursor's autonomous assistant that can read across your codebase, edit multiple files, and run terminal commands to complete a task end to end.

Step by step: press Cmd/Ctrl+I, describe the outcome you want ("add a dark mode toggle and persist the choice in localStorage"), and let the agent plan and execute. It creates checkpoints automatically before significant changes, so you can preview and restore any earlier state from the chat timeline if it goes sideways.

Real use: larger changes that touch several files, like wiring up a new route, its component, its tests, and the navigation link. The agent handles the spread while you review.

Tip: for a bigger, dedicated view, Cmd/Ctrl+Shift+I opens a fuller agent layout in current versions. Start with a clear, specific instruction. Vague prompts produce vague sprawl, and reviewing sprawl is slower than writing the code yourself.

7. Accept and reject AI edits without the mouse

Reviewing suggestions is where flow breaks if you reach for the trackpad. For inline Cmd/Ctrl+K edits, press Cmd/Ctrl+Y to accept the change and Cmd/Ctrl+N to reject it. Press Esc to dismiss a pending suggestion.

Real use: you are iterating quickly with Cmd/Ctrl+K, trying two phrasings of a prompt. Accept or reject each attempt from the keyboard and keep your hands in place.

Tip: for agent edits that span files, use the Accept all and Reject all controls in the chat so you approve a batch in one action after reviewing the diff.

Feed Cursor the right context with the @ system

AI output is only as good as the context you give it. Cursor's @ symbols let you hand the model exactly the right material instead of pasting code by hand. Type @ in any prompt bar or chat to open the menu.

8. Point at exact files and folders with @Files and @Folders

Type @ and start typing a filename or folder to attach it as context. @components/Button.tsx gives the model that file. Attaching a folder pulls in its structure and contents.

Real use: "refactor @utils/date.ts to use date-fns" gives Cursor the precise file rather than making it search. Targeted context produces sharper edits and uses fewer tokens than dumping your whole project in.

9. Reference symbols, not whole files, with @Code

@Code lets you attach a specific function, class, or snippet by name rather than an entire file. It keeps context tight when you only care about one piece.

Real use: "explain how @Code:parseInvoice handles partial payments" points the model at one function instead of the 800-line file it lives in, which keeps the answer focused and cheaper.

10. Pull framework documentation in with @Docs

@Docs injects external documentation into the conversation. Cursor ships with references for many popular frameworks and libraries, and you can add your own by URL.

Step by step: type @Docs in a prompt, pick a library like React, Next.js, or Tailwind, and Cursor uses that documentation when answering. To add a custom source, open the Docs settings and paste a documentation URL for Cursor to index.

Real use: a library just shipped a breaking change your model has not seen. Add its docs with @Docs and Cursor answers against the current API instead of an outdated memory.

11. Force a live web search with @Web

@Web tells Cursor to browse the live internet for current information rather than relying on training data.

Real use: "using @Web, find the latest recommended way to set up middleware in the newest Next.js" pulls fresh guidance for a fast-moving framework. Use it any time recency matters, such as new releases, changelogs, or error messages you are pasting in.

12. Review your own changes with @Git

@Git brings your version control state into context: diffs, commits, and branches. It turns Cursor into a reviewer of work you already did.

Real use: before opening a pull request, ask "using @Git, review my uncommitted changes for bugs and write a commit message." Cursor reads the actual diff and gives grounded feedback rather than generic advice.

Tip: this pairs well with a review habit. Run it as a last pass before every commit and you will catch small mistakes that slip past tired eyes.

Two editor shortcuts that are not AI but still save you time

Cursor inherits every VS Code shortcut, and two of them matter enough to call out because they remove friction around the AI features.

13. Open the command palette and remap any shortcut

Cmd+Shift+P (Ctrl+Shift+P) opens the command palette, your search box for every command in the editor. It is also how you customize the shortcuts in this guide.

Step by step: press Cmd/Ctrl+Shift+P, type "Keyboard Shortcuts", and open the editor to search any action and bind it to keys you prefer. You can also edit keybindings.json directly, and if you are migrating from VS Code, your existing keybindings and extensions carry over.

Real use: if Cmd/Ctrl+K clashes with muscle memory from another editor, rebind it in two minutes instead of fighting it for months.

14. Edit many places at once with multi-cursor

Select a word and press Cmd/Ctrl+D to add the next matching occurrence to your selection, then keep pressing to add more and edit them all at once. Add cursors vertically with Ctrl+Alt+Up or Ctrl+Alt+Down (Cmd+Opt+Up or Down on Mac). Press Esc to exit multi-cursor mode.

Real use: renaming a repeated literal or adding the same prop to several lines is often faster with multi-cursor than prompting the AI, and it is fully deterministic. Reach for AI when the change needs judgment, and multi-cursor when it is mechanical.

Hidden settings that change how Cursor works

Shortcuts speed up individual actions. These settings change Cursor's behavior across your entire project, and they are where the real leverage lives. Most developers never open them.

15. Give Cursor permanent instructions with Project Rules

Project Rules are the highest-leverage setting in Cursor. They are persistent instructions Cursor applies every time it works in your project, so you stop repeating yourself in every prompt. Rules live as .mdc files inside a .cursor/rules directory in your repo.

Step by step: create .cursor/rules in your project, add a file such as conventions.mdc, and write your standards inside, for example "use TypeScript strict mode, prefer functional components, never use default exports." Each rule has a type that controls when it applies: Always loads it into every request, Auto Attached loads it when you touch files matching a glob you set, Agent Requested lets Cursor pull it in when relevant, and Manual only loads when you reference it.

Real use: your team keeps getting AI code that ignores your conventions. Encode those conventions once as an Always rule, commit it, and every teammate gets consistent suggestions with zero manual setup.

Tip: keep rules short and specific. Long, vague rules dilute their effect. The older single-file .cursorrules at the project root still works, but the .cursor/rules directory with scoped rule types is the modern, more precise approach.

16. Build reusable prompts with custom slash commands

Custom slash commands turn a prompt you type often into a one-word command. They live as Markdown files in a .cursor/commands directory, where the filename becomes the command name and the file content becomes the prompt.

Step by step: create .cursor/commands/review.md containing your review checklist prompt. Now typing /review in chat runs it. Put commands in ~/.cursor/commands instead and they are available across all your projects.

Real use: a standardized "write a pull request description with test and documentation checkboxes" prompt becomes /pr, so every PR you open follows the same format without you retyping the instructions.

17. Control what Cursor sees with .cursorignore

By default Cursor can read your whole project, including secrets and generated noise. Two ignore files fix that. A .cursorignore file excludes paths from Cursor's AI features and indexing entirely. A .cursorindexingignore file excludes paths from indexing only, so they stay accessible on demand but do not clutter the index.

Step by step: create .cursorignore at your project root and add patterns like .env, secrets/, dist/, and node_modules/, using the same syntax as .gitignore.

Real use: keep environment files and API keys out of the model's reach, and stop build output from diluting the context Cursor pulls in. This is both a security setting and a quality setting, since a cleaner index produces more relevant results.

18. Tune codebase indexing for better answers

Cursor indexes your codebase into embeddings so it can find relevant code across files when you ask a broad question. This is what makes whole-project reasoning work, and you can control it.

Step by step: open Cursor Settings (the gear icon, or Cmd+Shift+J on most builds) and find the indexing section. Confirm indexing is on for projects where you want deep context, and pair it with .cursorignore so the index stays focused on real source code.

Real use: on a large repository, a well-tuned index is the difference between "search across my codebase for where auth is handled" returning the right files versus returning noise. On a tiny throwaway project, you can leave it off to save resources.

19. Switch modes and models to match the task

Cursor lets you change both how the AI behaves and which model runs, per task. The behavior modes are Agent (autonomously reads, edits, and runs commands), Ask (read-only, great for questions without touching files), Manual (pauses for your approval between steps), and Custom (your own instruction set and tool permissions). Switch between them from the mode dropdown in the chat input.

Step by step: for a risky refactor, start in Ask to understand the code, switch to Manual to approve each step, then move to Agent once you trust the plan. Pick the model from the dropdown in the same input, and enable a larger context option for supported models when a task needs to hold a lot of code at once.

Real use: exploring an unfamiliar bug is safer in Ask mode, where nothing gets edited. Shipping a well-understood feature is faster in Agent mode. Using the right mode prevents the two most common frustrations, an agent that edits too eagerly and a chat that will not act when you want it to.

Tip: Custom Modes are underused. Define a "reviewer" mode that can read and comment but not edit, and you have a repeatable, safe review workflow.

20. Speed up the agent safely with an auto-run allowlist

By default the agent asks permission before running terminal commands. You can reduce the interruptions with an auto-run allowlist, sometimes called YOLO mode, which lets approved commands run without a prompt. This is powerful and deserves real caution.

Step by step: in Cursor Settings, find the agent auto-run options and add only safe, read-only or reversible commands to the allowlist, such as your test runner or type checker. Keep destructive commands off the list.

Real use: letting npm test and tsc run automatically means the agent can write code, run the tests, read the failures, and fix them in a loop without stopping to ask each time. That closes the feedback loop and is where agentic coding starts to feel like magic.

Safety note: never blanket-approve every command, and never enable broad auto-run on a machine with production credentials or important local files. Treat the allowlist like sudo access. Turn on Privacy Mode in settings as well if you want a guarantee that your code is not stored or used for training. For connecting external tools and data sources to the agent, look at Cursor's MCP integration, which extends what the agent can safely reach.

Cursor shortcuts quick reference

Settings to configure once: .cursor/rules for persistent instructions, .cursor/commands for reusable prompts, .cursorignore for privacy and focus, plus indexing, modes, models, and the auto-run allowlist in Cursor Settings.

Key takeaways

The fastest way to level up in Cursor is to stop treating it like autocomplete. Match the tool to the task: Cmd/Ctrl+K for surgical edits, Cmd/Ctrl+L for thinking, Cmd/Ctrl+I for multi-file work, and Tab to ride the predictions. Feed it precise context with the @ system instead of pasting code. Then configure the project once with Project Rules, ignore files, and the right mode, so every session starts from a smarter baseline. Pick three of these today, use them until they are reflex, and come back for three more.