VS Code Extensions Worth Installing in 2026 (and What to Skip)

Every year, “best VS Code extensions” lists get regurgitated with the same twenty entries — including several that VS Code absorbed into core functionality years ago. Installing them today adds nothing but startup weight and update noise.

This list is different in two ways: it’s tested (each recommendation is running in my daily editor), and it includes the uninstall list — famous extensions you no longer need. Because the honest truth about editor performance in 2026 is that most “VS Code is slow” complaints are extension bloat wearing a trench coat.

First: what NOT to install anymore

VS Code ships these behaviors natively now. If you carry these extensions from an old setup, remove them:

The pattern: VS Code’s core team steadily absorbs the most popular utility extensions. A yearly audit against the built-ins keeps your editor lean — think of it as the editor equivalent of pruning dependencies.

Click to enlarge

Language support: the non-negotiables

These are only “extensions” technically; for their ecosystems they’re infrastructure. Install the ones matching your stack, skip the rest:

• ESLint + Prettier (JavaScript/TypeScript) — linting and formatting as you type, with "editor.codeActionsOnSave" auto-fixing on save. If your team has moved to Biome (the Rust-based lint+format all-in-one), its extension replaces both — one tool, one config, dramatically faster.
• Python (with Pylance) — and its companion Ruff, which has effectively become Python’s standard linter/formatter. The pairing made three older extensions redundant.
• rust-analyzer (Rust), gopls via the Go extension, Svelte/Vue/Astro official extensions for those frameworks.
• Tailwind CSS IntelliSense — if you write Tailwind, class autocomplete with color previews and hover documentation is the difference between fluency and tab-switching to docs.

Code quality and safety

Error Lens. Inlines diagnostics right where the error is — no hovering, no squinting at the Problems panel. The single best signal-to-effort ratio in the marketplace. Pro tip: set it to show only warnings and errors so hints don’t shout.

Code Spell Checker. Sounds trivial; isn’t. Typos in identifiers become bugs (recieved in one place, received in another) and embarrassments in docs. It’s code-aware, so camelCase splits correctly.

EditorConfig. Honors the .editorconfig file across a polyglot team. Boring, universal, correct.

GitLens. Inline blame, file history, comparing branches — git archaeology without leaving the editor. The free tier does everything most developers need. Pair it with actual Git fluency (our Git beyond the basics guide covers the command-line skills GitLens visualizes).

AI assistance: the category that ate the list

The biggest change to editor setups is that an AI assistant is now the default expectation, and your choice here dwarfs every other extension decision. The landscape in practice:

• GitHub Copilot — the incumbent: strong inline completions plus chat and an agent mode that can execute multi-file tasks.
• Claude Code / Anthropic tooling — the strongest at sustained, multi-step coding sessions and large-context work across a real codebase; runs in the terminal with an editor extension to anchor it in VS Code.
• Cursor and Windsurf — not extensions but VS Code forks rebuilt around AI; they import your settings and extensions wholesale. Whether editor-as-AI or AI-in-editor wins for you is genuinely a workflow preference.
• Continue / Cline — open-source assistants that connect to any model, including local ones served by Ollama (see our local LLM guide — private, unmetered autocomplete is a real option now).

Two pieces of advice that outrank the brand choice. First, write project instruction files (.github/copilot-instructions.md, CLAUDE.md, rules files — every tool has its flavor): a few paragraphs on your stack, conventions and taboos measurably upgrades every suggestion. It’s prompt engineering as configuration — the same principles from our prompt engineering guide apply verbatim. Second, learn to reject suggestions fast. The skill of AI-assisted coding is a fast accept/reject loop, not faith.

Quality of life

• Todo Tree — surfaces every TODO/FIXME in a sidebar, turning guilt into a queue.
• REST Client — write .http files and execute requests in-editor; requests live in git next to the code they exercise. Lighter than any API GUI for the common cases.
• Better Comments — colors ! warnings, ? questions and TODOs differently; cheap glanceability.
• Remote Development pack (SSH / Containers / WSL) — Microsoft’s official pack; full-fidelity editing inside containers and remote machines. If you work with Docker (our beginner’s guide pairs well), dev containers give the whole team an identical, versioned environment.
• A theme you love + an icon theme. Not productivity — morale. You stare at this thing eight hours a day. Current favorites in my rotation: the evergreen One Dark Pro and Catppuccin.

Keep it fast: extension hygiene

Three habits keep a decade-old install feeling new:

1. Audit annually. Sort the Extensions panel by “Installed,” and for each ask: did this help in the last month? Run the built-in Developer: Show Running Extensions command — it shows real activation times; anything slow that you barely use is a delete.
2. Use workspace recommendations. A .vscode/extensions.json in the repo ("recommendations": ["dbaeumer.vscode-eslint", ...]) prompts teammates to install exactly the team set — onboarding and consistency, solved.
3. Prefer profiles over mega-setups. VS Code Profiles let you keep a lean “writing” profile, a full “web dev” profile, a “Python” profile — each with only the relevant extensions active. Switching costs one click; the startup difference is real.

Frequently Asked Questions

How many extensions is too many? There’s no magic number — the metric is activation cost, not count. Thirty lazy-loading language extensions (which only activate for their file types) cost less than three eager ones that hook every keystroke. Run Developer: Show Running Extensions and judge by the milliseconds column: anything over ~200ms at startup should justify itself monthly. Most developers land comfortably at 15–25 well-chosen extensions per profile.

Should I switch to Cursor or another AI fork? Try one for a week if you’re curious — they import your VS Code settings, so the experiment is cheap. The forks integrate AI deeper (background agents, whole-codebase context by default); the trade is living slightly behind upstream VS Code releases and betting on a smaller vendor. Many developers get 90% of the value by pairing standard VS Code with a strong assistant plus a terminal agent. The honest answer: workflow preference, not a correctness question.

Are paid extensions and subscriptions worth it? The pattern that holds: pay for AI (the model quality difference is real and compounds daily), consider paying for GitLens Pro only if you live in complex multi-branch archaeology, and be skeptical of paid versions of things VS Code does natively. An AI subscription that saves twenty minutes a day pays for itself weekly at any developer salary.

Do extensions pose a security risk? Occasionally, yes — malicious and typosquatted extensions have appeared in the marketplace, and extensions run with your user’s permissions. Reasonable hygiene: prefer extensions with large install bases and named publishers, check that the publisher is verified for anything touching credentials, and avoid installing obscure extensions on machines with production access. Workspace recommendations from a trusted repo are safer than marketplace browsing.

Final Thoughts

The 2026 editor stack is smaller and more powerful than the 2020 one: the utility clutter moved into VS Code core, formatting and linting consolidated into faster unified tools, and one AI assistant now does what a shelf of snippet extensions used to pretend to. What remains genuinely valuable clusters around four jobs — deep language support, always-visible diagnostics, git context, and a well-configured AI pair.

So install deliberately, configure the instruction file, schedule the annual audit — and then stop optimizing the editor and go build something with it. The best extension setup is the one you no longer think about.