Best VS Code Extensions in 2026 (Curated, Not a Kitchen Sink)

VS Code has over 30,000 extensions in its marketplace. Most of them are fine. Some of them are genuinely excellent. A surprising number are redundant, unmaintained, or solve problems VS Code already handles natively. The goal of this guide is not to list everything — it’s to tell you what to actually install and, just as importantly, what to skip.

The core philosophy: fewer extensions, better editor

Every extension you install has a cost. Extensions add to startup time, consume memory, can conflict with each other, and occasionally break after a VS Code update. The cumulative effect of 40 casually installed extensions is a slow, unpredictable editor that feels worse than a clean install — which is why so many developers periodically nuke their setup and start over.

• Audit yearly: open your installed extensions list and ask, for each one: did I use this in the last month? If the answer is no, disable it. You can always re-enable it. You can’t un-accumulate the startup overhead of 30 forgotten extensions.
• Check what VS Code does natively first: Bracket Pair Colorizer was a beloved extension for years — VS Code made it a built-in setting in 2021. Auto-renaming HTML tags, basic snippets, and many other “extension” behaviors are already in the editor. Check the settings before installing.
• Workspace vs user settings: if an extension is only relevant to one project (say, Prisma schema formatting), install it but consider scoping it to that workspace rather than globally. Your Python extension doesn’t need to load when you’re writing Rust.

Essential for everyone

These five extensions earn a permanent slot in any VS Code setup, regardless of language or project type. If you only install five things from this entire guide, make it these.

• Prettier — auto-formats your code on save according to a consistent style. On solo projects this is a quality-of-life win; on team projects it’s non-negotiable. Prettier eliminates formatting debates entirely because the tool makes the decision, not the developer. It handles JavaScript, TypeScript, HTML, CSS, JSON, Markdown, and more. Set “editor.formatOnSave”: true in your settings and forget about it.
• ESLint — catches real bugs, not just style violations. The distinction matters: Prettier handles style, ESLint handles correctness. ESLint will flag undefined variables, unreachable code, accessibility violations (with the right plugins), and patterns that are legal JavaScript but almost certainly bugs. Configure it once per project via eslint.config.js and it runs on every save.
• GitLens — adds inline git blame to every line of code (hover any line to see who last changed it and in what commit), file history, commit search, and branch comparison. The free tier covers everything most developers need. If you have ever looked at a confusing line of code and wondered “who wrote this and why,” GitLens answers that question without leaving the editor.
• Error Lens — takes VS Code’s existing error and warning indicators (the red squiggles) and shows the error message inline at the end of the offending line, without requiring a hover. A tiny UX improvement with a disproportionately large impact on how fast you catch and fix problems. Zero configuration required.
• Path Intellisense — autocompletes file paths as you type import statements or string references. Catches typos in paths before they become runtime errors. Works across file types and is particularly useful in large projects where remembering the exact directory structure is impractical.

AI coding assistants

The AI coding extension category is the most crowded and fastest-changing part of the VS Code ecosystem. Options range from $10/month polished products to open-source tools you can run entirely locally. The right choice depends on your budget and how you feel about sending your code to external servers.

• GitHub Copilot — the best overall AI coding assistant as of 2026, and the one with the deepest VS Code integration. $10/month for individuals. Provides inline completions as you type, a chat panel for questions and code generation, and an agentic mode (Copilot Workspace) for multi-file edits. Context-awareness has improved substantially — it reads your open files and repository structure, not just the current cursor position. If you can justify the subscription, this is the one to start with.
• Continue — the best open-source alternative, and the right pick if you want AI coding without sending code to a vendor. Continue works with local models via Ollama (Llama 3, Qwen, Mistral, etc.) or via API (Claude, GPT-4o, Gemini). Fully configurable: point it at whichever model fits your budget and privacy requirements. Less polished than Copilot, but improving quickly and completely free at the local-model tier.
• Cody (Sourcegraph) — strongest for large codebases. Cody indexes your entire repository and uses that index to answer questions across files, find usages, and explain unfamiliar code. The free tier is generous. If you regularly need to onboard to large or legacy codebases, Cody’s codebase-wide context is more useful than Copilot’s file-level awareness.
• Cursor (a note, not an extension) — Cursor is a VS Code fork, not an extension. It can’t be installed from the VS Code marketplace. It’s worth knowing about because many developers switch to it specifically for AI-first editing, but it’s a separate application with a separate update cycle. If you want to stay in stock VS Code, Copilot or Continue is your path.

Git and collaboration

• GitHub Pull Requests — lets you review, comment on, and merge GitHub pull requests without leaving VS Code. See PR comments inline in the diff view, respond to review comments, and check out PR branches with a click. For teams using GitHub, this significantly reduces the context switching between editor and browser during code review.
• Git Graph — renders your repository’s branch and merge history as a visual graph, similar to what GitKraken or SourceTree show. Useful for understanding how branches relate to each other, tracing where a merge conflict originated, or untangling a rebase gone wrong. VS Code’s built-in source control panel handles day-to-day operations fine; Git Graph is for when you need to see the big picture.

Productivity and navigation

• TODO Highlight — visually surfaces TODO and FIXME comments across your codebase with configurable colors. You can also open the command palette and list all TODOs across open files. Simple, low-overhead, and useful for the inevitable gap between “I’ll fix this later” and actually fixing it later.
• Bookmarks — lets you bookmark specific lines across files and jump between them with keyboard shortcuts. Useful when working across a large codebase — bookmark the function definition you’re implementing, the test you’re writing, and the configuration file you keep referencing, and cycle between all three without cmd+clicking your way back each time.
• Project Manager — stores a list of your local projects and lets you switch between them with a quick-pick panel, without navigating the file system or reopening recent folders. If you work across multiple repositories regularly, this eliminates the friction of switching context.

Themes and appearance

Themes are entirely personal, but a few have earned wide adoption for good reasons. More importantly: VS Code’s font rendering and ligature support are good now — a quality monospace font (Fira Code, Cascadia Code, JetBrains Mono) with ligatures enabled does more for readability than any theme.

• One Dark Pro — consistently one of the most-downloaded VS Code themes. Based on Atom’s default dark theme. High contrast, good language token coverage, and familiar to a huge percentage of developers who migrated from Atom. A safe default if you want dark and don’t want to think about it.
• Catppuccin — warmer, softer contrast than One Dark Pro. Four variants (Latte, Frappe, Macchiato, Mocha) from light to dark. Better for long coding sessions if high-contrast themes cause eye strain. Has become the default aesthetic for developers who find One Dark a bit harsh.
• Material Icon Theme — replaces VS Code’s default file icons with a comprehensive set of language- and framework-specific icons. At a glance you can tell a TypeScript file from a JavaScript file from a JSON config from a Docker file. Worth installing purely for the navigational clarity in the file explorer.

Language-specific picks worth calling out

These are only relevant if you’re working in the specific stack, but they’re good enough that they’re worth installing the moment you are.

• Pylance + Python (Microsoft) — install both as a pair. Python provides the language runtime integration and debugger; Pylance provides fast, accurate type checking and IntelliSense powered by Pyright. This combination gives you something close to PyCharm’s Python intelligence inside VS Code. Do not install third-party Python extensions alongside these — they conflict.
• Tailwind CSS IntelliSense — autocompletes Tailwind utility classes as you type, shows the underlying CSS on hover, and flags invalid class names. If you write Tailwind, this goes from “useful” to “how did I write Tailwind without this” within about ten minutes.
• Prisma — syntax highlighting, formatting, and auto-completion for Prisma schema files. Also integrates with the Prisma extension to format .prisma files on save via Prettier. Small extension, useful specifically where it applies.
• REST Client — lets you write HTTP requests directly in .http files and execute them from within VS Code. A lightweight replacement for Postman or Insomnia for quick API tests during development. The .http files live in your repo, version-controlled alongside the API they test. Particularly useful for documenting expected request shapes without spinning up a separate tool.

Extensions to skip

The contrarian section. These are extensions that have strong reputations but are worth reconsidering before installing.

• Live Share — Microsoft’s real-time collaboration extension sounds ideal but is heavy, occasionally unreliable, and requires both developers to be online simultaneously for a synchronous session. If you pair-program multiple times a week, it’s worth the setup cost. If you pair-program occasionally, a screen share on Tuple, Zoom, or Slack is lower friction and works better. Install it when you need it, not preemptively.
• Bracket Pair Colorizer — this extension was enormously useful when it was the only way to get colorized bracket pairs. In 2021, VS Code made bracket pair colorization a built-in feature (enable it via "editor.bracketPairColorization.enabled": true in settings). The extension is now redundant and the authors officially deprecated it. If you have it installed, uninstall it and enable the native setting instead.
• Snippet packs — most language snippet packs (React snippets, Vue snippets, HTML snippets) produce worse code than writing it yourself because they encode patterns from the time they were written, which may no longer reflect current idioms. They also train you to fill-in-the-blank rather than understand the structure. Use the built-in Emmet abbreviations for HTML/CSS, and write component structures by hand until they’re muscle memory. The AI completions from Copilot or Continue are a better version of this idea anyway.

Who should install what

The takeaway

The VS Code extension marketplace is a supermarket: useful when you know what you need, dangerous when you browse with no list. Install the five essentials (Prettier, ESLint, GitLens, Error Lens, Path Intellisense), add one AI assistant, and then only extend from there when you hit a specific problem that an extension would solve.

The developers with the best VS Code setups are almost never the ones with the most extensions. They’re the ones who installed carefully, trimmed ruthlessly, and actually configured what they kept.