Ctrl+Shift+P (Cmd+Shift+P on macOS) opens a fuzzy search over every command the editor and every installed extension exposes. It is the discovery mechanism: you do not need to know where "Toggle Word Wrap" lives in the menus, you type "wrap". It also shows the keybinding next to each command, so it teaches you shortcuts while you use it.
Three siblings are worth the same muscle memory. Ctrl+P is quick open, fuzzy matching file paths, so usrctrl finds src/users/UserController.ts. Type @ in that box to jump to a symbol in the current file, # to search symbols across the workspace, and : followed by a number to go to a line. Once these are automatic, you stop using the file tree, which is the point.
F12 goes to definition, Alt+F12 peeks it inline without leaving the file, and Shift+F12 lists every reference. Ctrl+Minus goes back to where you were, which is what makes deep navigation safe. These are powered by a language server, not by text search, so they follow imports and re-exports correctly and know the difference between two functions with the same name.
F2 renames a symbol across the project through that same language server, updating imports as it goes, and it will refuse rather than silently corrupt when it cannot resolve something. For JavaScript and TypeScript this works out of the box; for Python, Go, Rust and the rest, installing the official language extension is what turns the editor from a text editor into an IDE.
For a rename that has real semantics, use F2. Multi-cursor is for the cases the language server cannot help with, such as reformatting a block of JSON or turning ten lines into ten function calls.
There are two layers. User settings apply everywhere; workspace settings live in .vscode/settings.json inside the repository and win. Formatter choice, tab width and lint behaviour belong in the workspace file and should be committed, so everyone on the team produces identical diffs. Theme and font size belong to you.
{
"files.autoSave": "onFocusChange",
"editor.formatOnSave": true,
"editor.defaultFormatter": "esbenp.prettier-vscode",
"[python]": { "editor.defaultFormatter": "charliermarsh.ruff" },
"editor.codeActionsOnSave": { "source.fixAll.eslint": "explicit" },
"files.trimTrailingWhitespace": true,
"files.insertFinalNewline": true,
"editor.bracketPairColorization.enabled": true,
"search.exclude": { "**/dist": true, "**/.next": true }
}A per-language defaultFormatter block is the fix for the most common new-user complaint, which is two formatters fighting and the file changing every save. Prefer onFocusChange over afterDelay for autosave, because delay-based saving triggers file watchers and rebuilds while you are mid-word.
Ctrl+backtick opens the integrated terminal, and multiple terminals can be split side by side, which is enough for a dev server plus a test watcher. But the real upgrade is .vscode/launch.json. A minimal Node config:
{
"version": "0.2.0",
"configurations": [{
"type": "node",
"request": "launch",
"name": "Debug tests",
"program": "${workspaceFolder}/node_modules/.bin/vitest",
"args": ["run", "${relativeFile}"],
"console": "integratedTerminal",
"skipFiles": ["<node_internals>/**"]
}]
}Click the gutter to set a breakpoint, then use the parts most people never touch: right-click a breakpoint to add a condition such as user.id === 42 so it only fires on the case you care about, or make it a logpoint that prints an expression without pausing and without editing the file. Enable "Caught Exceptions" in the breakpoints panel when you have a swallowed error and no stack trace. skipFiles keeps you out of runtime internals when stepping.
Remote-SSH runs the editor's server component on the remote machine while the UI stays local, so file watching, search, language servers and the terminal all execute where the code lives. That is completely different from editing over a mounted network share, which is slow and breaks tooling. Dev Containers does the same against a container defined by .devcontainer/devcontainer.json, so the toolchain version, system libraries and extensions come from a file in the repository rather than from a wiki page nobody updated.
Both are worth setting up the moment "works on my machine" appears twice in a week. The cost is that everything now runs at the speed of the remote box and container rebuilds take minutes.
Extensions run in a separate extension host process, so a bad one cannot crash the window, but it can make every keystroke lag. Run "Developer: Show Running Extensions" from the palette to see activation times and CPU profiles, and "Help: Start Extension Bisect" to binary-search the culprit automatically. Launch with code --disable-extensions to confirm the editor itself is fine. Most slowdowns come from three sources: a second formatter or linter doing the same job, a file watcher indexing node_modules, and language servers for languages you are not using.
Rebind rather than relearn: keybindings.json takes when clauses, so a key can do one thing in the editor and another in the terminal. As for other editors: Neovim gives the fastest editing model and the largest configuration burden, and its Lua plugin ecosystem plus built-in LSP client has closed most of the feature gap. Zed is fast, has collaboration built in, and a thinner extension ecosystem. Helix ships batteries-included with LSP and tree-sitter and no plugin system to maintain. The JetBrains IDEs still have the strongest refactoring and database tooling for large Java, Kotlin and Python codebases, and they are paid. The editor matters far less than whether you have configured format on save, a working debugger and a language server.