VS Code ships with a capable baseline, but the real productivity gains come from extensions. The marketplace now has over 55,000 of them — and that number makes picking the right ones harder, not easier. Most extensions are abandoned, poorly maintained, or solve problems you don't have. A few dozen are genuinely career-changing.
This guide cuts through the noise. Every extension listed here has been vetted against three criteria: it must be actively maintained (updated within the last 6 months), it must have a measurable impact on daily workflow, and it must not compromise editor performance when combined with other essential tools. You'll get real extension IDs, actual settings.json snippets, and an opinionated minimal setup for fresh installs.
How to Evaluate an Extension Before Installing
Before adding any extension, check four things in the marketplace listing: the install count (low numbers aren't automatically bad, but warrant scrutiny), the last updated date (anything over 18 months with open issues is a risk), the issue tracker (look for responsiveness from maintainers), and whether it bundles its own language server or relies on system-level tooling you need to configure separately.
Extensions that inject themselves into every file type — regardless of whether you're working in that language — are the biggest source of editor slowdowns. Use VS Code's built-in extension host process inspector (Developer: Show Running Extensions) to identify culprits before they become a problem.
AI Coding Assistants
AI coding extensions have matured dramatically. In 2026, the question isn't whether to use one — it's which one fits your workflow and budget.
GitHub Copilot (GitHub.copilot)
The most widely deployed AI coding assistant. Copilot's ghost-text suggestions integrate tightly with VS Code's native completion system and its multi-file context window handles repository-scale completions better than it did in previous versions. The github.copilot.chat companion extension adds an in-editor chat panel that can reference your open files, explain errors inline, and generate unit tests on demand.
// settings.json
{
"github.copilot.enable": {
"*": true,
"markdown": false,
"plaintext": false
},
"github.copilot.advanced": {
"inlineSuggestCount": 3
}
}
The markdown: false setting prevents Copilot from autocompleting prose, which is almost always wrong. Keep it focused on code files.
Continue (Continue.continue)
The open-source alternative that lets you connect your own model backends — Anthropic Claude, OpenAI, Ollama local models, or any OpenAI-compatible API. Continue supports full codebase context via embeddings, making it better than Copilot for working within a specific repository's conventions. If you're running a self-hosted setup or want to use Claude Sonnet without a Copilot subscription, Continue is the right choice.
// settings.json
{
"continue.telemetryEnabled": false,
"continue.enableTabAutocomplete": true
}
Configure your models in ~/.continue/config.json — the extension ships with a visual editor for this.
Codeium (Codeium.codeium)
Free tier, no token limits, trained on a large corpus of permissively licensed code. Codeium is the strongest option if you want AI completions without a subscription. Its context window is smaller than Copilot's, but for single-file and small-project work the quality is comparable. Enable only the autocomplete feature and leave the chat panel off unless you actively use it — it adds to startup time.
// settings.json
{
"codeium.enableConfig": {
"*": true,
"markdown": false
}
}
Code Quality & Formatting
Getting formatting right once and never thinking about it again is one of the highest-leverage investments in developer experience.
Prettier (esbenp.prettier-vscode)
The de facto code formatter for JavaScript, TypeScript, CSS, HTML, JSON, Markdown, and YAML. Set it as the default formatter for every file type you work with and enable format-on-save. The key configuration decision is whether to use a project-level .prettierrc or a global fallback — always prefer project-level so your formatting matches your team's config.
// settings.json
{
"editor.formatOnSave": true,
"editor.defaultFormatter": "esbenp.prettier-vscode",
"[python]": {
"editor.defaultFormatter": "ms-python.black-formatter"
},
"prettier.requireConfig": false,
"prettier.singleQuote": true,
"prettier.semi": true,
"prettier.trailingComma": "es5"
}
ESLint (dbaeumer.vscode-eslint)
ESLint handles what Prettier doesn't: logical errors, unused variables, accessibility violations, and framework-specific rules. In 2026 most projects use the flat config format (eslint.config.js). The extension auto-detects which config format you're using.
// settings.json
{
"eslint.enable": true,
"eslint.run": "onType",
"editor.codeActionsOnSave": {
"source.fixAll.eslint": "explicit"
}
}
Set eslint.run to "onSave" if you're on slower hardware — running on every keystroke is the default but it adds CPU overhead.
Error Lens (usernamehw.errorlens)
Error Lens moves diagnostic messages (errors, warnings, hints) inline to the end of the offending line instead of requiring you to hover over a red squiggle. The difference in how quickly you spot and fix problems is significant. Zero configuration required out of the box, but you can tune the delay and severity levels:
// settings.json
{
"errorLens.enabledDiagnosticLevels": ["error", "warning"],
"errorLens.delay": 300,
"errorLens.followCursor": "activeLine"
}
Git & Version Control
Version control extensions are the single category where spending time on configuration pays off the most. Bad Git tooling creates context-switching overhead multiple times per hour.
GitLens (eamodio.gitlens)
GitLens is the most comprehensive Git extension available for any editor. The free tier covers blame annotations, the current line blame overlay, the commit graph, file history, and the interactive rebase editor. The Pro tier adds worktrees and additional visual diff tools, but the free version is already more capable than most teams use.
The blame overlay showing the last commit to touch the current line is the feature developers notice first. The commit graph — now available free — lets you visualize branches without leaving VS Code.
// settings.json
{
"gitlens.currentLine.enabled": true,
"gitlens.currentLine.format": "${author}, ${agoOrDate} • ${message|50}",
"gitlens.hovers.currentLine.over": "line",
"gitlens.blame.compact": true
}
Git Graph (mhutchie.git-graph)
Where GitLens excels at line-level blame and history, Git Graph excels at the repository-wide branch view. Its interactive graph lets you checkout branches, cherry-pick commits, rebase interactively, and compare branches side-by-side. It's faster than the GitLens commit graph for repositories with complex branch histories.
No special configuration needed — install it and open it via the status bar or View: Show Git Graph command.
Git History (donjayamanne.githistory)
Fills the gap that neither GitLens nor Git Graph covers well: searching commit history by file, by author, or by date range, with a clean diff view of each commit. Use it when you need to answer "when did this function change and why" without running git log in a terminal.
Navigation & Search
The best navigation extensions reduce the distance between where you are and where you need to be.
Path Intellisense (christian-kohler.path-intellisense)
Autocompletes file paths in import statements, require() calls, HTML src and href attributes, and CSS url() functions. Essential for projects with deep directory structures. It respects tsconfig.json path aliases automatically.
// settings.json
{
"path-intellisense.mappings": {
"@": "${workspaceFolder}/src"
},
"path-intellisense.autoSlashAfterDirectory": true
}
Bookmarks (alefragnani.bookmarks)
Lets you mark specific lines in any file and jump between them with keyboard shortcuts. Underrated for large codebases — mark the entry points, the hot paths, and the files you're actively changing, then cycle through them without using file history. Bookmarks persist across sessions and sync with Settings Sync.
Keyboard shortcuts to memorize: Ctrl+Alt+K toggle bookmark, Ctrl+Alt+J previous, Ctrl+Alt+L next.
Todo Tree (Gruntfunn.todo-tree)
Scans your workspace for TODO, FIXME, HACK, and custom comment tags, then displays them in a tree view in the sidebar. Prevents the classic problem of "TODO comments that become permanent documentation." Configure it to show a badge count on the sidebar icon so you always know how many outstanding items exist.
// settings.json
{
"todo-tree.general.tags": ["TODO", "FIXME", "HACK", "NOTE", "BUG"],
"todo-tree.highlights.defaultHighlight": {
"foreground": "white",
"background": "#F5A623",
"icon": "alert",
"type": "text"
}
}
Remote Development
Remote development extensions have become essential infrastructure as teams spread across WSL, Docker containers, and cloud VMs.
Remote SSH (ms-vscode-remote.remote-ssh)
Opens a full VS Code workspace — including extensions, terminals, and debuggers — on any machine reachable via SSH. The extension tunnels VS Code Server to the remote host, so you're editing files directly rather than syncing them. Performance is indistinguishable from local editing on a fast connection.
Configure your ~/.ssh/config with Host aliases before using this extension — it reads that file and makes connection management much cleaner.
Dev Containers (ms-vscode-remote.remote-containers)
Runs your entire development environment inside a Docker container defined by a .devcontainer/devcontainer.json file in your repository. The container specification ships with the repo, which means every contributor gets the same environment with the same tool versions. This is the correct solution to "works on my machine" — not documentation telling people which Node version to install.
// .devcontainer/devcontainer.json (minimal example)
{
"name": "Node.js",
"image": "mcr.microsoft.com/devcontainers/javascript-node:22",
"features": {
"ghcr.io/devcontainers/features/github-cli:1": {}
},
"customizations": {
"vscode": {
"extensions": ["esbenp.prettier-vscode", "dbaeumer.vscode-eslint"]
}
}
}
WSL (ms-vscode-remote.remote-wsl)
On Windows, this extension gives VS Code access to the WSL filesystem and Linux toolchain as if you were working natively on Linux. Required if you're using any Linux-native tooling (specific versions of Node via nvm, Python environments, shell scripts) from a Windows machine. Far more reliable than trying to run Unix tooling through Git Bash or Cygwin.
Language-Specific Must-Haves
Install only what matches your actual stack — extension sprawl is a performance problem.
Python
Pylance (ms-python.vscode-pylance) — the language server that powers type checking, import resolution, and autocomplete for Python. Use this instead of the generic Python extension's built-in analysis. Set python.analysis.typeCheckingMode to "basic" to catch real errors without drowning in noise from untyped third-party libraries.
Black Formatter (ms-python.black-formatter) — the opinionated Python code formatter. Configure it as the default formatter for .py files (see the Prettier config above).
Ruff (charliermarsh.ruff) — the Rust-based Python linter that replaces flake8, isort, pyupgrade, and a dozen other tools. 10-100x faster than the Python tooling it replaces. In 2026, this should be your default Python linter.
TypeScript / JavaScript
TypeScript Error Translator (mattpocock.ts-error-translator) — translates TypeScript's notoriously verbose error messages into plain English. Small install, high value. No configuration required.
Import Cost (wix.vscode-import-cost) — displays the bundle size of imported packages inline, next to the import statement. Prevents the "accidentally imported all of lodash" class of mistakes before they reach a build.
Go
Go (golang.go) — the official Go extension from the Go team. Non-negotiable for Go development. It wraps gopls, the Go language server, and provides formatting via gofmt, test running, debugging, and refactoring tools. Install it and run Go: Install/Update Tools from the command palette to set up the full toolchain.
Rust
rust-analyzer (rust-lang.rust-analyzer) — the official Rust language server. Provides completions, type inference display, inline diagnostics, and the best "fill in the blanks" experience for implementing traits of any language extension in VS Code. Replaces the legacy rls extension — if you have both installed, remove the old one.
Themes & UI
Themes are personal, but these three are consistent performers across monitors, lighting conditions, and long working sessions.
One Dark Pro (zhuangtongfa.material-theme)
The most-installed VS Code theme with good reason. The contrast ratios are optimized for extended sessions and it maintains semantic color differentiation better than most alternatives. The Monokai variant included in the pack adds a warmer palette for those who prefer it.
Material Icon Theme (PKief.material-icon-theme)
Replaces VS Code's default file icons with a comprehensive set that covers every major file type and framework. The visual differentiation between component.tsx, component.test.tsx, and component.stories.tsx alone makes it worth installing.
// settings.json
{
"workbench.iconTheme": "material-icon-theme",
"material-icon-theme.folders.color": "#90a4ae"
}
Peacock (johnpapa.vscode-peacock)
When you regularly work with multiple VS Code windows — different projects, different repos — Peacock assigns a distinct accent color to each window's title bar and activity bar. Eliminates the constant "which window am I in" cognitive overhead. Color each project something memorable and the navigation becomes automatic.
Workflow Automation
Task Runner (SanaAjani.taskrunnercode)
Surfaces the scripts defined in your package.json, Makefile, Taskfile.yml, or VS Code tasks.json in a sidebar panel with run buttons. Faster than opening a terminal and typing script names, especially for tasks you run infrequently enough that you can't remember the exact command.
REST Client (humao.rest-client)
Lets you write HTTP requests in .http or .rest files using a simple syntax and execute them directly from VS Code. The response appears in a split panel. Variables, environments, and request chaining are supported, making it a lightweight alternative to Postman for API development workflows that live in your repo alongside the code that calls the API.
### Get user
GET https://api.example.com/users/{{userId}}
Authorization: Bearer {{token}}
Content-Type: application/json
### Create post
POST https://api.example.com/posts
Authorization: Bearer {{token}}
Content-Type: application/json
{
"title": "New Post",
"body": "Content here"
}
Thunder Client (rangav.vscode-thunder-client)
A full GUI API client embedded in VS Code — closer to Postman in interface than REST Client. Supports collections, environment variables, test scripting, and GraphQL. If your team is already comfortable with a Postman-style interface but wants to keep API testing inside the editor, Thunder Client is the right pick.
The Minimal Power Setup: Top 10 for a Fresh Install
When setting up a new machine or environment, install these 10 extensions before anything else. They cover the highest-value use cases across all stacks and languages:
code --install-extension esbenp.prettier-vscode \
--install-extension dbaeumer.vscode-eslint \
--install-extension usernamehw.errorlens \
--install-extension eamodio.gitlens \
--install-extension mhutchie.git-graph \
--install-extension christian-kohler.path-intellisense \
--install-extension PKief.material-icon-theme \
--install-extension ms-vscode-remote.remote-ssh \
--install-extension ms-vscode-remote.remote-containers \
--install-extension rangav.vscode-thunder-client
From here, layer in your AI assistant of choice (Copilot, Continue, or Codeium) and the language-specific extensions for your stack. Every other extension in this guide is optional depending on your workflow.
Tips: Managing Extensions for Peak Performance
Use Profiles to Separate Contexts
VS Code Profiles (available since 1.75) let you maintain separate extension sets for different types of work. Create a "Frontend" profile with React/TypeScript extensions, a "Python Data" profile with Jupyter and Pylance, and a "Writing" profile with spell check and Markdown tools. Switch profiles from the gear icon in the lower-left corner. This approach is faster than manually enabling and disabling extensions and prevents cross-contamination between toolchains.
Audit Activation Events Regularly
Every extension declares when it activates — on startup, on file open, on command. Extensions with * as their activation event run on every window open regardless of whether you're using them. Check the Developer: Show Running Extensions panel and look for extensions taking over 50ms to activate. That's your kill list.
Disable Workspace-Wide, Not Globally
When working in a repository where a specific extension is irrelevant — say, the Go extension when you're only editing Python — disable it for the workspace rather than globally. Right-click the extension in the Extensions panel and select "Disable (Workspace)". This keeps your global config clean and makes context-appropriate tool selection automatic.
Keep Settings in a Gist or Settings Sync
VS Code's built-in Settings Sync (sign in with GitHub or Microsoft) syncs extensions, keybindings, settings, and profiles across machines automatically. For teams where you want to standardize extension sets, the alternative is checking a .vscode/extensions.json file into each repository with the recommendations array — VS Code will prompt any developer who opens the repo to install the listed extensions.
// .vscode/extensions.json
{
"recommendations": [
"esbenp.prettier-vscode",
"dbaeumer.vscode-eslint",
"eamodio.gitlens",
"usernamehw.errorlens"
]
}
Handle Extension Conflicts Proactively
Some extension combinations create conflicts — two formatters fighting over the same file type, two language servers registering for the same file extension, two Git tools making competing status bar entries. The most common conflict is Prettier and a language-specific formatter. Resolve it explicitly with per-language editor.defaultFormatter settings rather than hoping they coexist gracefully.
Putting It All Together
The extensions that matter most aren't the most impressive ones — they're the ones you use every hour. Prettier and ESLint run on every save. GitLens annotation is visible every time you read code you didn't write. Error Lens catches problems before you run the code. These quiet, always-on tools compound over the course of a workday into a significant reduction in friction.
The AI assistants and workflow automation tools matter too, but they require investment to configure well. Set up Continue with your preferred model backend. Build out your REST Client .http files alongside your API code. Create VS Code profiles for each type of work you do regularly.
Start with the minimal power setup above, add language-specific extensions as you need them, and audit the full list every few months to remove anything you're not actively using. A lean, well-configured extension set outperforms a bloated one every time.
Build faster with the right tools. DevPlaybook at devplaybook.cc hosts free, no-account-required developer tools — JSON formatter, regex tester, JWT decoder, Base64 encoder, cron expression generator, UUID generator, and 30+ more utilities that live in your browser tab alongside VS Code. Bookmark the ones you reach for daily and eliminate the context switch to external sites.
Level Up Your Dev Workflow
Found this useful? Explore DevPlaybook — cheat sheets, tool comparisons, and hands-on guides for modern developers.
🛒 Get the DevToolkit Starter Kit on Gumroad — 40+ browser-based dev tools, source code + deployment guide included.
Top comments (0)