25 VS Code Extensions Worth Installing in 2026

You probably have 30 extensions you don't need

Extension bloat creeps up on everyone. Pile up 60 or 80 and the editor takes forever to start, crashes when two extensions fight each other, and occasionally an extension silently modifies your code on save and costs you an afternoon of debugging.

The fix is to uninstall everything and add back, one by one, only the extensions that solve a real problem in your daily workflow.

The 25 below are the ones worth that spot. They're grouped by category, and for each you'll find why it matters, what it does, and any settings tweaks that make it better.

If you're at zero extensions or a hundred, this list should help you find a reasonable middle ground. My bias is toward fewer.

AI and code assistance

1. GitHub Copilot

Published by GitHub, and by a wide margin my most-used extension. Inline code suggestions are scarily accurate for boilerplate, and the chat feature is excellent for explaining unfamiliar codebases, especially the kind of legacy project where the original authors left years ago and the only documentation is a README that says "TODO." The Copilot-powered code review suggestions in pull requests have also turned out surprisingly useful.

My settings: I keep "github.copilot.inlineSuggest.enable": true but set "github.copilot.enable": { "markdown": false, "plaintext": false } to kill suggestions in non-code files, where they're more annoying than helpful.

There's a free tier with a monthly cap on completions. Copilot Pro costs $10/month, and it's free for verified students and some open-source maintainers.

2. Error Lens

Publisher: Alexander. Instead of making you hover over a red squiggly line to read an error, Error Lens prints the error inline at the end of the offending line. That sounds minor, and it changes how fast you spot and fix problems: you see the issue the moment you type the wrong thing, instead of thirty seconds later when you notice a faint underline.

Settings I use:

{
  "errorLens.enabledDiagnosticLevels": ["error", "warning"],
  "errorLens.messageMaxChars": 120,
  "errorLens.fontStyleItalic": true
}

I turn off the "info" and "hint" levels. Only errors and warnings show.

3. Pretty TypeScript Errors

Publisher: yoavbls. TypeScript error messages are notoriously unreadable, especially with complex generic types. You know the ones, a wall of angle brackets and nested conditional types that makes your eyes glaze over. This extension formats them into a readable layout with syntax highlighting. It saves a lot of squinting.

API testing

4. Thunder Client

Publisher: Ranga Vadhineni. Thunder Client is basically Postman built into VS Code. You create HTTP requests, organize them into collections, set environment variables, and run tests without leaving your editor. I stopped using Postman entirely after switching.

Thunder Client is no longer fully free, though. The free plan caps you at 3 collections with 50 requests each, and paid plans start at $3 per user per month, billed annually.

What you get:

• Request collections with folder organization
• Environment variables (local, global)
• Response history
• Import/export Postman collections
• GraphQL support

The big selling point for me is that it doesn't need a separate Electron window eating 500MB of RAM. It's fast.

5. REST Client

Publisher: Huachao Mao. Thunder Client gives you a GUI; REST Client has you write HTTP requests as plain text in .http or .rest files. The upside is that your API test cases can be version controlled alongside your code.

### Get all users
GET https://api.example.com/users
Authorization: Bearer {{token}}

### Create a user
POST https://api.example.com/users
Content-Type: application/json

{
  "name": "Anurag",
  "email": "anurag@example.com"
}

Click "Send Request" above any block. The response appears in a side panel. I use REST Client for API documentation and Thunder Client for quick ad-hoc testing.

Git and version control

6. GitLens

Publisher: GitKraken. GitLens adds a great deal on top of VS Code's built-in Git support and pairs well with a solid Git workflow (if you're still getting comfortable with Git, our Git and GitHub mastery guide covers the fundamentals). Inline blame annotations show who last modified each line and when. That's incredibly useful when you're trying to figure out why a piece of code exists. The file history and line history views let you trace how specific code evolved over time.

The feature I use most is "Reveal Commit in Side Bar." When I'm staring at a confusing line, I right-click, see who wrote it and when, then open the full commit for context. Mystery solved in 10 seconds. It probably saves me 20 minutes a week.

Settings I use:

{
  "gitlens.codeLens.enabled": false,
  "gitlens.currentLine.enabled": true,
  "gitlens.hovers.currentLine.over": "line"
}

I disable CodeLens (the inline reference counts above functions) because I find it visually distracting. Current-line blame stays on.

Code quality and formatting

7. Prettier

Publisher: Prettier. Consistent formatting wipes out a whole category of bikeshedding in code reviews: semicolons, single vs double quotes, trailing comma wars. Prettier formats on save according to a shared configuration. Everyone moves on.

The settings that matter:

{
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "[javascript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
  "[typescript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
  "[json]": { "editor.defaultFormatter": "esbenp.prettier-vscode" }
}

8. ESLint

Publisher: Microsoft. Prettier handles formatting, while ESLint catches code quality issues like unused variables, potential bugs, and accessibility violations, so running both gives you formatting plus linting and covers the vast majority of code quality concerns automatically, before a reviewer ever has to leave a comment about them.

Turn on auto-fix on save and you barely have to think about it:

{
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  }
}

9. Code Spell Checker

Publisher: Street Side Software. Typos in variable names, comments, and strings are embarrassing in code reviews, and they can cause real bugs too (misspelled API field names, anyone?). A recieve instead of receive in a response handler can eat an hour of debugging.

Add your project-specific terms to a workspace dictionary so they don't show up as false positives:

{
  "cSpell.words": ["anurag", "frontmatter", "astro", "tailwindcss", "vite"]
}

10. Better Comments

Publisher: Aaron Bond. It color-codes comments by prefix: // ! turns red (alerts), // ? blue (queries), // TODO orange, and // * green (highlights). Scanning comments gets much faster and the important notes stand out. More teams should agree on consistent comment prefixes. It seems like a small thing until you're hunting through 500 lines of code for that one warning someone left.

HTML, CSS, and frontend

11. Tailwind CSS IntelliSense

Publisher: Tailwind Labs. If you use Tailwind CSS, this is mandatory. You get autocomplete for all utility classes, hover previews of the CSS a class generates, and flags for invalid class names. It also reads your custom theme configuration from tailwind.config.js. Without it you're memorizing hundreds of class names.

12. Auto Rename Tag

Publisher: Jun Han. Rename an opening HTML/JSX tag and the closing tag updates automatically. It's dead simple and prevents the mismatched-tag bugs that eat debugging time. You don't realize how often you rename tags until something handles it for you.

13. CSS Peek

Publisher: Pranay Prakash. Hover over a CSS class in your HTML to peek at its definition without switching files, or Ctrl+click to jump straight to the CSS rule. With large stylesheets, when you can't remember where .card-container-wrapper-inner is defined, it's a lifesaver.

14. Import Cost

Publisher: Wix. It shows the size of imported JavaScript packages inline, right next to the import statement. Once you see that importing moment adds 72KB to your bundle while date-fns/format adds only 2KB, you start making better decisions. I can't say it has changed anyone's mind about lodash, but it has made me think twice before reaching for a large library when a smaller one exists.

Productivity and navigation

15. Todo Tree

Publisher: Gruntfutz. It scans your whole codebase for TODO, FIXME, HACK, and other comment tags and lists them in a sidebar tree view, so all those "TODO: fix this later" comments finally show up in one place. Some of mine were two years old. The guilt alone was motivating.

16. Project Manager

Publisher: Alessandro Fragnani. If you work on multiple projects (who doesn't?), Project Manager saves them and lets you switch with a single click, so you stop going through File > Open Folder and clicking through directories. I have about 12 projects saved and switching takes under a second. It adds up.

17. Path Intellisense

Publisher: Christian Kohler. It autocompletes file paths as you type them in import statements, require calls, or HTML src attributes, which prevents typos in file references and speeds up imports a lot. It works so unobtrusively that you forget it's there, until you sit at someone else's machine and find yourself typing full paths like an animal.

18. Turbo Console Log

Publisher: ChakrounAnas. Select a variable, press Ctrl+Alt+L, and it inserts a meaningful console.log statement below the current line, labelled with the variable name. When you're done debugging, Alt+Shift+D deletes every console.log statement the extension generated. It's faster than typing them yourself, and each log carries the variable name as context. Am I proud that I debug with console.log? No. Does this extension make it faster? Absolutely.

Remote development and containers

19. Docker

Publisher: Microsoft. You get syntax highlighting and IntelliSense for Dockerfiles and docker-compose files, plus a visual interface for managing containers, images, and registries from inside VS Code. Right-clicking a running container and choosing "Attach Shell" is incredibly handy. I no longer jump to a terminal window to check what's going on inside a container.

20. Remote - SSH

Publisher: Microsoft. It opens a folder on a remote server over SSH as if it were local, which makes it a must-have if you develop on a Linux server. Your whole VS Code setup (extensions, terminal, IntelliSense, debugging) runs on the remote machine. I use it daily for cloud VMs and my home server.

Add the servers you use often to ~/.ssh/config for one-click connections:

Host dev-server
  HostName 192.168.1.100
  User anurag
  IdentityFile ~/.ssh/id_ed25519

21. Live Share

Publisher: Microsoft. This is real-time collaborative editing, like Google Docs for code. Share a link and your collaborator can see and edit your code in their own VS Code instance, with shared terminals and debugging sessions too. I use it a lot for pair programming with remote teammates. It's probably the closest remote work gets to sitting next to someone.

Visual enhancements

22. Material Icon Theme

Publisher: Philipp Kief. It swaps the default file icons for distinctive, colorful ones for every file type: a yellow JS icon for JavaScript, blue for TypeScript, curly braces for JSON, and so on. It's partly cosmetic. On large projects with dozens of similarly named files in different formats, though, recognizing file types at a glance in the explorer saves real time.

23. indent-rainbow

Publisher: oderwat. Each indentation level gets its own subtle shade, so in deeply nested code (Python, YAML, complex JSX) it's much easier to see which block you're in. The colors are muted on purpose. I didn't think I needed this until I installed it, and now I notice right away when it's missing.

Documentation

24. Markdown All in One

Publisher: Yu Zhang. You get keyboard shortcuts for Markdown formatting, automatic table of contents generation, auto-preview, and list continuation. It makes writing READMEs, documentation, or blog posts in Markdown (like this one) noticeably smoother.

The shortcuts I use most:

• Ctrl+B for bold
• Ctrl+I for italic
• Alt+C to toggle checkbox
• Ctrl+Shift+] to increase heading level

One that deserves a special mention

25. Bracket pair colorization (built in)

There used to be a popular extension called "Bracket Pair Colorizer" that color-matched opening and closing brackets. In 2021 the VS Code team built the feature into the editor itself, and it runs significantly faster than the extension ever did. It has been on by default since VS Code 1.67, so you don't install anything. These settings make it explicit and add bracket guides:

{
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active"
}

Setting bracketPairs to "active" draws a vertical line linking the bracket pair your cursor is inside, which helps a lot in complex nested structures. It's one of the best examples of the VS Code team absorbing a popular extension into the core product.

My complete settings.json for extensions

Here are all the extension-related settings I use in one place:

{
  // Formatting
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },

  // Bracket pairs (built-in)
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active",

  // GitLens
  "gitlens.codeLens.enabled": false,
  "gitlens.currentLine.enabled": true,
  "gitlens.hovers.currentLine.over": "line",

  // Error Lens
  "errorLens.enabledDiagnosticLevels": ["error", "warning"],
  "errorLens.messageMaxChars": 120,

  // Copilot
  "github.copilot.inlineSuggest.enable": true,
  "github.copilot.enable": {
    "markdown": false,
    "plaintext": false
  },

  // Spell Checker
  "cSpell.words": ["frontmatter", "astro", "tailwindcss"],

  // Misc
  "workbench.iconTheme": "material-icon-theme"
}

Extensions I deliberately skip

Knowing what to leave out matters about as much as knowing what to install. These are popular extensions you can safely remove:

• GitHub Copilot Chat (standalone) is now part of the main Copilot extension, so the standalone version is redundant.
• Settings Sync is built into VS Code now. Turn it on under Settings > Turn on Settings Sync; no extension needed.
• Bracket Pair Colorizer 2 is obsolete, since the built-in version replaces it.
• Live Server is largely replaced by Vite or the Next.js dev server, which have HMR and are faster.
• Beautify is deprecated in favor of Prettier.

Each of these was fine in its day, and some of them were essential a few years ago, before VS Code absorbed their features or better tools came along to replace them. If they're still sitting in your extensions list gathering dust, uninstall them.

Keeping VS Code fast

More extensions means slower startup and higher memory use. That's just physics. A few habits keep things snappy:

1. Disable extensions per workspace. You don't need Docker extensions while writing a Python script, so right-click an extension and choose "Disable (Workspace)" to switch it off for specific projects. It takes two seconds and makes a real difference.

2. Check startup performance. Open the Command Palette and run "Developer: Show Running Extensions" to see which extensions eat the most resources. Anything consistently above 100ms activation time deserves a hard look.

3. Go easy on extension packs. A pack installs several extensions at once. Often you'll only use 2-3 out of a pack of 10. That leaves 7 extensions consuming resources for nothing.

4. Update regularly. Extension authors optimize performance often. Outdated extensions can also conflict with newer VS Code versions.

Build your own stack, and be honest about what you need

My 25 fit my workflow as a full-stack TypeScript developer. Yours will look different.

Python developers should add Python (Microsoft), Pylance, Jupyter, and Black Formatter, while Java folks want the Extension Pack for Java (Microsoft) and the Spring Boot Extension Pack, and Go developers need Go (Google), which packs almost everything into a single extension. Rust? Add rust-analyzer. And if you're a TypeScript developer, our advanced TypeScript patterns guide covers the type-level techniques that make extensions like Pretty TypeScript Errors and Copilot even more useful.

This next bit might sound harsh: stop installing everything that looks cool. Every extension costs you something. Install what you need, configure it properly, and then audit the list every few months, removing whatever has gone stale along with anything whose job the editor now does on its own, the way it already did for bracket colors and settings sync.

An editor works best as a sharp tool that fits your hand. A bloated Christmas tree of features you enabled once and forgot about is the opposite. A lot of VS Code performance complaints come from people running 60+ extensions they installed on a whim and never revisited. Don't be that person.