The VS Code Shortcuts Deep-Dive: Beyond Copy and Paste

VS Code is one of those tools where the gap between casual users and power users is almost entirely a shortcut gap. Two people can have the exact same extensions installed and the exact same project open, and one of them will move through the codebase two or three times faster than the other — not because they type faster, but because they never touch the mouse for navigation, selection, or refactoring. The full VS Code shortcut reference covers every shortcut on this site; this post is about the handful that actually change how editing feels.

Quick Open and the Command Palette: stop browsing the file tree

Ctrl+P (Cmd+P on Mac) — Quick Open — is the single most important VS Code shortcut, full stop. It opens a fuzzy-search file picker: start typing any part of a filename and it narrows down instantly. Once this is automatic, clicking through the file tree in the sidebar becomes something you almost never do, because typing three or four characters of a filename is faster than visually scanning a nested folder structure, especially in a large codebase.

Ctrl+Shift+P (Cmd+Shift+P) opens the Command Palette — a fuzzy-search list of literally every command VS Code exposes, from 'Format Document' to 'Change Language Mode' to obscure settings you'd otherwise need to dig through a menu to find. Once you're comfortable with the Command Palette, you rarely need to remember exact shortcuts for less-common actions, because typing a rough description of what you want to do and picking the matching command is nearly as fast as a dedicated shortcut, and works for literally everything the editor can do.

Multi-cursor editing: the feature that changes how you refactor

This is the category most casual VS Code users never fully learn, and it's the biggest productivity gap between them and people who use the editor daily for serious work. Ctrl+D (Cmd+D on Mac) selects the current word and, pressed again, selects the next occurrence of that same word — building up multiple cursors that let you edit several instances of a variable name or string simultaneously. Alt+Click (Option+Click on Mac) drops an additional cursor anywhere you click, for cases where the edits aren't at identical text but at specific, unrelated locations.

Ctrl+Shift+L selects every occurrence of the current selection in the whole file at once — useful for a rename-in-place across a file without invoking a full rename-symbol refactor. Alt+Shift+I (Option+Shift+I) puts a cursor at the end of every line in the current selection, which is the fastest way to append the same text (a comma, a semicolon, a comment) to a block of consecutive lines. Once these four are automatic, a huge fraction of small refactors that used to require careful manual editing — or worse, find-and-replace with regex — become a five-second multi-cursor operation. See the multi-cursor editing category page for the complete set.

Navigation that keeps you in the code, not the file tree

F12 (or Ctrl+Click / Cmd+Click on a symbol) jumps to a function or variable's definition; Alt+F12 (Option+F12) peeks at the definition in an inline popup without leaving your current file — extremely useful for a quick check without losing your place. Ctrl+- (Cmd+-) navigates back to your previous cursor location, and Ctrl+Shift+- goes forward again, functioning like browser back/forward buttons for your editing history. This pair alone eliminates most of the 'wait, where was I' moments that come from jumping around a large file or between files while tracing logic.

Ctrl+G (Cmd+G) jumps directly to a specific line number — faster than scrolling when you already know exactly where you need to go, for instance from a stack trace or a linter error. Ctrl+Shift+O (Cmd+Shift+O) lists every symbol (function, class, variable) in the current file and lets you jump straight to one — much faster than scrolling through a long file looking for a specific function. See the navigation category for the rest, including split-editor and tab-switching shortcuts.

Terminal and panes without breaking flow

Ctrl+` (Cmd+`) toggles the integrated terminal open and closed — the fastest way to run a quick command without switching to a separate terminal application and losing your editor context. Ctrl+B (Cmd+B) toggles the sidebar, which is worth doing on smaller screens to reclaim horizontal space while you're deep in an editing session and don't need the file tree visible.

Debugging without reaching for the mouse

F9 toggles a breakpoint on the current line — faster than clicking in the gutter, and it works even when your cursor isn't precisely positioned over the gutter's clickable area. F5 starts or continues debugging, F10 steps over the current line, and F11 steps into a function call. Once these four are automatic, an entire debugging session can happen without a single mouse click, which matters because debugging already involves enough context-switching between your code and the debugger's state without adding manual clicking on top. See the debugging category page for the complete set, including Shift+F11 to step out of the current function.

If you use Cursor instead

Cursor is built on the same underlying editor as VS Code, so nearly all of the shortcuts above carry over directly, with Cursor's AI-specific shortcuts layered on top. If you switch between the two regularly, that overlap is good news — you're not learning two separate shortcut systems, just one extra layer.

Terminal shortcuts pair well with this

If a meaningful part of your workflow happens in a terminal alongside the editor — running builds, git commands, or test suites — it's worth pairing this list with the terminal power-user tips post, since the two skill sets reinforce each other: fast in-editor navigation means less time spent per edit, and fast terminal usage means less time spent between edits.

Building the habit

As with any shortcut set, reading this list won't make it automatic — only repetition will. The Shortcut Trainer is set up to drill exactly the shortcuts covered here, tracking which ones you keep missing so they resurface more often until pressing Ctrl+D or F12 stops requiring conscious thought at all.