VS Code Shortcuts and Settings Cheat Sheet (The 20 That Save Hours)

VS Code Shortcuts and Settings Cheat Sheet

Visual Studio Code ships with hundreds of keybindings. Roughly twenty of them account for nearly all the time you can save.

This sheet lists those twenty first, then the settings worth changing on a fresh install. Every table gives Windows/Linux and macOS keys side by side.

Updated for 2026. Covers VS Code 1.9x, all shortcuts at default bindings.

The Command Palette

Learn this one first. The palette exposes every command in the editor and every installed extension, fuzzy-searchable, and it displays the keyboard shortcut beside each command.

That last detail makes it a teaching tool. You discover shortcuts while using the thing they trigger, which is the only way they actually stick.

What people get wrong: treating the palette as a fallback for rare commands. It is faster than the menu bar for almost everything, including ones you use daily.

Navigation

Ctrl+P accepts prefixes, and this is the part most people never learn:

Ctrl+P  then  @symbolName     → jump to a symbol in the current file
Ctrl+P  then  #symbolName     → search symbols across the workspace
Ctrl+P  then  :42             → jump to line 42
Ctrl+P  then  file.ts:42      → open a file directly at line 42
Ctrl+P  then  >               → becomes the command palette

One keystroke opens a prompt that does five different jobs depending on the first character you type. Ctrl+P then @ replaces scrolling for a symbol in a 900-line file.

Alt+← (go back) is the underrated one. After chasing a definition three files deep, it walks you back along exactly the path you came.

Multi-Cursor Editing

Four methods, four different jobs:

What people get wrong: hammering Ctrl+D past an occurrence they did not want and starting over. Ctrl+K Ctrl+D skips the current match and moves to the next one, keeping everything already selected.

Selection and Line Editing

Expand selection is the most underused shortcut in the editor. Press it once from inside a string and you select the string; again and you have the argument list; again the whole call; again the statement; again the enclosing block. It is syntax-aware, so it always selects a structurally valid region.

That means you never need to drag-select a function again — and shrink selection walks it back if you overshoot.

Alt+↑/Alt+↓ moves a line without cut and paste, and it re-indents automatically as it crosses block boundaries.

Refactoring

Why F2 beats find-and-replace

F2 is language-aware. It asks the language server which references belong to this specific symbol, then updates all of them across the whole project — including imports, exports, and re-exports — and shows a preview first.

Find-and-replace is a text operation. It has no idea what a scope is, so it will happily rewrite:

• the same word inside a string literal
• the same word in a comment
• an unrelated local variable in another function
• a property on a completely different object

// F2 on `count` renames ONLY this variable and its references
const count = items.length;
// It leaves this alone:
const message = "count of items";     // string literal
user.count = 5;                        // different symbol entirely

The distinction only matters when it goes wrong, which is why so many developers learn it the expensive way. If a rename is not purely mechanical, F2 is not optional. The TypeScript cheat sheet covers the language-server features that make this work.

Ctrl+. opens the quick-fix menu on any squiggle: import the missing module, extract to a function, convert to arrow syntax, add a missing property. It is where most of the editor's refactoring lives.

Search and Replace

With regex mode on, the replace field supports capture group references:

Find:     const (\w+) = require\('(.+)'\)
Replace:  import $1 from '$2'

That converts CommonJS requires to ES module imports across a whole project. $1 and $2 insert whatever the parenthesised groups captured. The regex cheat sheet covers the pattern syntax in full.

The files to include and files to exclude boxes take glob patterns — src/**/*.ts, !**/dist/** — which is how you keep a search out of build output and node_modules.

Terminal and Panels

The backtick toggle is the highest-frequency shortcut on this page for most developers. Opening a terminal already rooted in the project directory removes the context switch to a separate application entirely — pair it with the Git commands cheat sheet and most version-control work never leaves the editor.

Split Editors

Ctrl+Shift+T reopens the file you just closed by accident, and it works repeatedly going backwards through your close history.

Shift+Alt+0 flips a split between vertical and horizontal, which matters more than it sounds on a laptop screen where side-by-side is too narrow to read.

Debugging

Conditional breakpoints are the feature worth adopting. Right-click the gutter and enter an expression such as user.id === 4218, and execution pauses only when it is true.

This replaces the habit of adding a console.log inside an if, running, reading, editing, and re-running. A loop of ten thousand iterations stops on the one that matters, with the full call stack and every variable in scope available.

Logpoints are the same menu's other option: a breakpoint that prints a message instead of pausing. It gives you logging without editing the source file, which means no accidental debug statement in a commit.

Settings Worth Changing

{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": { "source.organizeImports": "explicit" },
  "files.autoSave": "onFocusChange",
  "files.trimTrailingWhitespace": true,
  "files.insertFinalNewline": true,
  "editor.stickyScroll.enabled": true,
  "editor.linkedEditing": true,
  "editor.minimap.enabled": false,
  "explorer.compactFolders": false,
  "workbench.editor.enablePreview": false
}

What each one buys you:

• formatOnSave — you stop thinking about formatting, and diffs stop containing whitespace noise.
• organizeImports on save — dead imports are removed automatically, so the linter stops complaining.
• autoSave: onFocusChange — saves when you leave the window. Safer than afterDelay, which can trigger a rebuild mid-keystroke.
• stickyScroll — pins the enclosing function and class headers at the top of the viewport. In a long file this is the difference between knowing and guessing where you are.
• linkedEditing — editing an HTML or JSX opening tag updates the closing tag as you type.
• enablePreview: false — stops single-click file opens from replacing each other in the same italic tab. Every file you open stays open.
• compactFolders: false — the explorer stops collapsing src/components/ui into one line, which makes it clickable at each level.

What people get wrong: installing a formatter extension and never enabling formatOnSave, then formatting manually with Shift+Alt+F and forgetting half the time. The result is a repository where formatting changes are scattered through unrelated commits.

Settings Sync

Built in — no extension needed. Click the account icon at the bottom of the activity bar, sign in with GitHub or a Microsoft account, and choose what to sync:

A new machine goes from blank to fully configured in about two minutes. Keybindings are stored per platform, so a Windows desktop and a Mac laptop share one profile without overwriting each other.

The Five Mistakes

1. Using find-and-replace to rename a symbol. F2 understands scope; text matching does not. It will rewrite strings, comments, and unrelated variables.

2. Never learning Ctrl+P prefixes. @, #, : and > turn one shortcut into five tools. Most people use only the file search.

3. Debugging with console.log instead of conditional breakpoints. Edit, run, read, edit again — versus stopping exactly once on iteration 4,218 with the whole stack visible.

4. Installing a formatter without formatOnSave. Manual formatting is inconsistent formatting, and it pollutes every diff.

5. Ignoring Settings Sync. Every reinstall or new laptop costs an afternoon of reconfiguration that a two-minute sign-in would have eliminated.

Print This Section

PALETTE   Ctrl/Cmd+Shift+P     everything, searchable, shows keybindings
FILES     Ctrl/Cmd+P           then  @symbol  #workspace  :line  >command

CURSORS   Alt/Opt+Click        arbitrary position
          Ctrl/Cmd+Alt+↑↓      aligned column
          Ctrl/Cmd+D           next occurrence  (Ctrl+K Ctrl+D = skip)
          Ctrl/Cmd+Shift+L     all occurrences
          Esc                  back to one

SELECT    Shift+Alt+→          expand selection (syntax aware)
          Alt/Opt+↑↓           move line     Ctrl/Cmd+Shift+K  delete line
          Ctrl/Cmd+/           toggle comment

REFACTOR  F2                   rename symbol — NEVER find-and-replace
          Ctrl/Cmd+.           quick fix / extract / import

SEARCH    Ctrl/Cmd+Shift+F     all files    Alt+R = regex, $1 in replace

PANELS    Ctrl+`  terminal   Ctrl/Cmd+B sidebar   Ctrl/Cmd+J panel
          Ctrl/Cmd+\  split    Ctrl/Cmd+Shift+T  reopen closed file

DEBUG     F5 run   F9 breakpoint   F10 over   F11 into   Shift+F11 out
          right-click gutter → conditional breakpoint / logpoint

SETTINGS  formatOnSave · autoSave onFocusChange · stickyScroll
          enablePreview false · organizeImports on save

Pick three shortcuts from this page and use only those for a week. Trying to adopt twenty at once means adopting none — the ones that stick are the ones you were forced to repeat.

🔗 Next in this collection: JavaScript Cheat Sheet, or return to The Complete Developer Cheat Sheet Collection.