25 VS Code Extensions Worth Installing in 2026

Your VS Code Is Probably Running 30 Extensions It Doesn't Need

I know because mine used to run 80. Eighty extensions. My editor took forever to start, occasionally crashed when extensions conflicted with each other, and I once spent two hours debugging an issue that turned out to be an extension silently modifying my code on save. Fun times.

After that particularly maddening debugging session, I nuked everything. Uninstalled every single extension. Started from zero. And then, one by one, I added back only the ones that solved a real problem in my actual daily workflow.

Now I run exactly 25 extensions. Each one has earned its place. I've organized them into categories, and for each one I'll explain why it matters, what it actually does, and any settings tweaks that make it better.

Whether you're running VS Code with zero extensions or with a hundred, this list should help you find a reasonable middle ground. Though honestly? I think most developers would be better off with fewer extensions, not more.

AI and Code Assistance

1. GitHub Copilot

Publisher: GitHub Why it matters: Copilot has become my most-used extension by a wide margin. Not close. Inline code suggestions are scarily accurate for boilerplate, and the chat feature is excellent for explaining unfamiliar codebases. Copilot-powered code review suggestions in pull requests have also been a surprisingly useful addition.

Settings tip: 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.

Cost: Rs 800/month (Individual) or free for verified students and open-source maintainers.

2. Error Lens

Publisher: Alexander Why it matters: Instead of making you hover over a red squiggly line to read an error message, Error Lens displays the error inline at the end of the offending line. Sounds minor. It isn't. It fundamentally changes how fast you spot and fix problems — you see the issue the moment you type the wrong thing, not thirty seconds later when you notice a faint underline.

Settings tip:

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

I disable "info" and "hint" levels to cut visual noise. Only errors and warnings. Keeps the editor clean.

3. Pretty TypeScript Errors

Publisher: yoavbls Why it matters: 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. Pretty TypeScript Errors formats them into a human-readable layout with syntax highlighting. If you write TypeScript, this extension alone will save you countless minutes of squinting at type error soup.

API Testing

4. Thunder Client

Publisher: Ranga Vadhineni Why it matters: Thunder Client is basically Postman built into VS Code. Create HTTP requests, organize them into collections, set environment variables, run tests — all without leaving your editor. I stopped using Postman entirely after switching to this.

Key features:

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

Here's the real selling point: it doesn't require a separate Electron window eating 500MB of RAM. Lightweight and fast.

5. REST Client

Publisher: Huachao Mao Why it matters: While Thunder Client gives you a GUI, REST Client takes a different approach — you write HTTP requests as plain text in .http or .rest files. Why does that matter? Because 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, and the response appears in a side panel. I use REST Client for API documentation and Thunder Client for quick ad-hoc testing. Different tools, different jobs.

Git and Version Control

6. GitLens

Publisher: GitKraken Why it matters: GitLens supercharges VS Code's built-in Git support, and it pairs perfectly 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 you who last modified each line and when. Incredibly useful when you're trying to figure out why a piece of code exists. File history and line history views let you trace how specific code evolved over time.

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

Settings tip:

{
  "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 Why it matters: Consistent code formatting eliminates an entire category of bikeshedding in code reviews. No more arguing about semicolons. No more single-vs-double-quote debates. No more trailing comma wars. Prettier formats on save according to a shared configuration, and everyone moves on with their lives.

Essential settings:

{
  "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 Why it matters: Prettier handles formatting. ESLint catches actual code quality issues — unused variables, potential bugs, accessibility violations, and more. Running both together gives you formatting plus linting, which covers the vast majority of code quality concerns automatically.

Settings tip: Enable auto-fix on save for a hands-off experience:

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

9. Code Spell Checker

Publisher: Street Side Software Why it matters: Typos in variable names, comments, and strings are embarrassing in code reviews. Worse, they can cause actual bugs. Misspelled API field names, anyone? Spent forty-five minutes once tracking down a bug that turned out to be recieve instead of receive in a response handler. Never again.

Settings tip: Add your project-specific terms to a workspace dictionary so they don't flag false positives:

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

10. Better Comments

Publisher: Aaron Bond Why it matters: Color-codes your comments based on prefixes. // ! becomes red (alerts), // ? becomes blue (queries), // TODO becomes orange, and // * becomes green (highlights). Makes scanning through comments way faster and helps important notes pop visually. I think more teams should adopt consistent comment prefixes — it seems like a small thing until you're hunting through 500 lines of code trying to find that one warning someone left.

HTML, CSS, and Frontend

11. Tailwind CSS IntelliSense

Publisher: Tailwind Labs Why it matters: If you use Tailwind CSS, this isn't optional. Autocomplete for all utility classes, hover to see the actual CSS a class generates, flags for invalid class names. It also picks up your custom theme configuration from tailwind.config.js. Without it, you're basically memorizing hundreds of class names. With it, you're barely thinking about them.

12. Auto Rename Tag

Publisher: Jun Han Why it matters: Rename an opening HTML/JSX tag, and the closing tag updates automatically. Dead simple. Prevents the mismatched-tag bugs that waste time debugging. You don't realize how often you rename tags until something automatically handles it for you.

13. CSS Peek

Publisher: Pranay Prakash Why it matters: Hover over a CSS class in your HTML and peek at its definition without switching files. Or Ctrl+click to jump directly to the CSS rule. When you've got large stylesheets and can't remember where .card-container-wrapper-inner is defined, this is a lifesaver.

14. Import Cost

Publisher: Wix Why it matters: Shows the size of imported JavaScript packages inline, right next to your import statement. When you see that importing moment adds 72KB to your bundle while date-fns/format adds only 2KB, you start making better decisions. Not sure if it's changed anyone's mind about lodash, but it's definitely made me think twice about reaching for large libraries when smaller alternatives exist.

Productivity and Navigation

15. Todo Tree

Publisher: Gruntfutz Why it matters: Scans your entire codebase for TODO, FIXME, HACK, and other comment tags, then displays them in a tree view in the sidebar. Finally, all those "TODO: fix this later" comments scattered across your project become visible in one place. Some of mine were two years old. The guilt alone was motivating.

16. Project Manager

Publisher: Alessandro Fragnani Why it matters: If you work on multiple projects (and who doesn't?), Project Manager lets you save projects and switch between them with a single click. No more File > Open Folder and navigating through directories. I've got about 12 projects saved. Switching takes under a second. Small quality-of-life improvement that adds up to real time saved over a week.

17. Path Intellisense

Publisher: Christian Kohler Why it matters: Autocompletes file paths as you type them in import statements, require calls, or HTML src attributes. Prevents typos in file references and speeds up imports significantly. One of those extensions that works so quietly in the background that you forget it's there — until you use someone else's machine and suddenly you're typing full paths like an animal.

18. Turbo Console Log

Publisher: ChakrounAnas Why it matters: Select a variable, press Ctrl+Alt+L, and it inserts a meaningful console.log statement below the current line with the variable name as a label. Press Alt+Shift+D to delete all console.log statements generated by this extension when you're done debugging. Faster than typing them manually and cleaner because each log includes 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 Why it matters: Syntax highlighting and IntelliSense for Dockerfiles and docker-compose files, plus a visual interface for managing containers, images, and registries directly from VS Code. Being able to right-click a running container and "Attach Shell" is incredibly handy. No more switching to a terminal window to check what's happening inside a container.

20. Remote - SSH

Publisher: Microsoft Why it matters: Open a folder on a remote server via SSH as if it were local — a must-have if you're doing development on a Linux server. Your entire VS Code experience — extensions, terminal, IntelliSense, debugging — works on the remote machine. I use this daily for work on cloud VMs and my home server.

Settings tip: Add your frequently used servers 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 Why it matters: Real-time collaborative editing, like Google Docs but for code. Share a link, and your collaborator can see and edit your code in their own VS Code instance. Shared terminals and debugging sessions too. I use this extensively for pair programming with remote teammates. It's probably the closest thing to sitting next to someone that remote work offers.

Visual Enhancements

22. Material Icon Theme

Publisher: Philipp Kief Why it matters: Replaces default file icons with distinctive, colorful icons for every file type. JavaScript gets a yellow JS icon, TypeScript gets blue, JSON gets curly braces, and so on. Sounds cosmetic. It's not entirely. Being able to instantly identify file types in the explorer saves real time on large projects where you've got dozens of files with similar names but different extensions.

23. indent-rainbow

Publisher: oderwat Why it matters: Colors each indentation level with a different subtle shade. In deeply nested code — Python, YAML, or complex JSX — this makes it dramatically easier to see which block you're in. Colors are intentionally muted enough that they don't become distracting. I didn't think I needed this until I installed it, and now I notice immediately when it's missing.

Documentation

24. Markdown All in One

Publisher: Yu Zhang Why it matters: Keyboard shortcuts for Markdown formatting, automatic table of contents generation, auto-preview, and list continuation. If you write READMEs, documentation, or blog posts in Markdown (like this one), this extension makes the process noticeably smoother.

Key shortcuts:

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

One That Deserves Special Mention

25. Bracket Pair Colorization (Built-in!)

Used to be a popular extension called "Bracket Pair Colorizer" that would color-match opening and closing brackets. In 2021, the VS Code team built this feature natively into the editor, and it runs significantly faster than the extension ever did. No install needed. Just make sure it's turned on.

Enable it:

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

Setting bracketPairs to "active" draws a vertical line connecting the bracket pair your cursor is currently inside, which helps tremendously for navigating complex nested structures. I think this is one of the best examples of the VS Code team absorbing popular extension functionality into the core product.

My Complete settings.json for Extensions

Here's a consolidated view of the extension-related settings I use:

{
  // 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 Don't Use

Knowing what not to install is arguably as important as knowing what to install. Here are popular extensions I've tried and removed:

• GitHub Copilot Chat (standalone): Now integrated into the main Copilot extension, so the standalone version is redundant.
• Settings Sync: VS Code has built-in settings sync now. Turn it on under Settings > Turn on Settings Sync. No extension needed.
• Bracket Pair Colorizer 2: Obsolete — use the built-in version.
• Live Server: I use Vite or Next.js dev server instead, which have HMR and are faster.
• Beautify: Deprecated in favor of Prettier.

Each of these was fine in its time. They aren't needed anymore. Uninstall them if they're still sitting in your extensions list gathering dust.

Keeping VS Code Fast

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

1. Disable extensions per workspace. You don't need Docker extensions when writing a Python script. Right-click an extension and choose "Disable (Workspace)" to turn it off for specific projects. Takes two seconds. Makes a real difference.

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

3. Use extension packs sparingly. Extension packs install multiple extensions at once. Make sure you actually need all of them — often you'll only use 2-3 out of a pack of 10. That's 7 extensions consuming resources for nothing.

4. Update regularly. Extension authors frequently optimize performance. Outdated extensions can cause conflicts with newer VS Code versions and run slower than their current releases.

Build Your Own Stack, But Be Honest About What You Need

My list of 25 is tailored to my workflow as a full-stack TypeScript developer. Yours will look different.

Python developers should add: Python (Microsoft), Pylance, Jupyter, Black Formatter.

Java developers should add: Extension Pack for Java (Microsoft), Spring Boot Extension Pack.

Go developers should add: Go (Google), which packs almost everything into a single extension.

Rust developers should add: rust-analyzer, which provides an IDE-like experience that's genuinely excellent. For TypeScript developers specifically, our advanced TypeScript patterns guide covers the type-level techniques that make extensions like Pretty TypeScript Errors and Copilot even more useful.

But here's what I really want to say, and it might sound harsh: stop installing everything that looks cool. Seriously. Every extension you add is a trade-off — startup time, memory, potential conflicts, cognitive overhead from extra features you don't use. Install what you need. Configure it properly. Audit your list every few months. Remove what's gone stale.

Your editor should be a sharp, personalized tool that fits your hand. Not a bloated Christmas tree of features you enabled once and forgot about. I suspect half the VS Code performance complaints out there come from people running 60+ extensions they installed on a whim and never revisited. Don't be that person.

If you've got an extension that's genuinely improved your workflow and I didn't mention it here, I'd love to hear about it in the comments. Best tool recommendations always come from people who use them daily, not from listicles recycling the same 50 suggestions every year.