I've been using VS Code daily for the past four years. I've installed probably 80 extensions across that time. Most of them I deleted within a week. Some became so essential that I panic when I switch devices and forget to install them.
This isn't a listicle of "top extensions" pulled from other blogs. This is what's actually sitting in my Extensions folder right now, why each one stays, and honestly—which ones I've reconsidered.
The Productivity Core (Extensions You'll Use Every Single Day)
Let me start with the non-negotiables. These are the extensions that, if I had to reset my entire setup, would be the first ones I'd reinstall.
1. Prettier – Code Formatter
Prettier does one thing: it formats your code consistently. No arguments, no debates. You write messy code, Prettier cleans it up automatically on save.
I used to be skeptical about auto-formatting. I thought it would override my personal style. Then I realized—that's the entire point. Style debates are a waste of time. Prettier ends them.
The catch? It's opinionated. Very opinionated. Some developers hate that. I actually love it now because my brain has one fewer thing to care about. However, if your team uses a different formatter (like Black for Python), you'll need to configure it or skip this.
Real talk: On a team project last month, I forgot Prettier was installed and spent 15 minutes arguing about indentation with a colleague. We both realized we just needed to run Prettier. Problem solved.
2. ESLint
ESLint catches bugs before they happen. Unused variables, missing semicolons, logical errors—it's like having a code reviewer in your editor.
What I appreciate: you can ignore warnings you genuinely disagree with. I could be wrong here, but I think ESLint gets a bad reputation because people configure it too strictly initially. Dial it back. Let your team agree on what actually matters.
One frustration—sometimes ESLint and Prettier clash on formatting rules. If you use both, you need `eslint-config-prettier` to make them play nice. Worth it? Yes. Takes five minutes to set up? Also yes.
3. GitLens
GitLens shows you who wrote each line of code and when. Sounds trivial. It's not.
I used to blame teammates for bad code, then realized that code was written two years ago by me. GitLens prevented that embarrassment multiple times. It also helps when you're trying to understand *why* a line exists—you can see the commit message.
Fair warning: it can slow down VS Code if your repository is massive. On smaller projects, it's seamless. On a legacy codebase with 50,000+ commits, there's a noticeable lag on file load. Still worth it for the context it provides.
The Intelligent Coding Assistants (Your Extra Brain)
4. GitHub Copilot
Copilot writes code for you using AI. You start typing, it suggests completions. Sometimes shockingly accurate. Sometimes hilariously wrong.
Here's my honest take: it's incredible for boilerplate. Setting up Redux reducers, writing test stubs, creating API endpoints—Copilot finishes them 80% of the time, and you just tweak the last 20%. That saves maybe 2-3 hours a week.
Where it fails spectacularly? Complex logic. Business rules. Anything that requires actual understanding of your problem domain. I've had Copilot suggest solutions that looked right but had subtle bugs that would tank production.
Cost is $10/month or included with GitHub Pro. For freelancers and indie developers, that stings a bit. For agencies and startups, it's probably worth it if you calculate time saved.
I used to think Copilot would replace junior developers. I was wrong. Instead, it makes junior developers much faster. That's actually better—it means the job market shifts toward strategy and architecture, not copy-pasting CRUD operations.
5. Tabnine
Tabnine is Copilot's quieter cousin. It's also AI-powered code completion, but more conservative in suggestions. Runs partially on your machine (privacy-first approach).
The free version is solid. Paid version ($15/month) adds features like chat and repository-wide completions. Honestly? I tested it side-by-side with Copilot and Tabnine's suggestions felt more reliable for production code. Less jazz-hands, more steady results.
If you're uncomfortable with sending code to OpenAI's servers (valid concern), Tabnine has a local-only mode. That's a genuine differentiator.
The Navigation Helpers (Because Clicking Through Files Gets Old)
6. Thunder Client (or REST Client)
Testing APIs without leaving your editor. Thunder Client is VS Code's built-in equivalent to Postman, but lighter and faster.
Why not just use Postman? Postman is excellent, but it's a separate application. You context-switch. Thunder Client lives in your editor. It sounds like a small thing. It compounds.
REST Client is the open-source alternative (free). Thunder Client is newer, prettier, and includes a database explorer now. I switched to Thunder Client three months ago and haven't regretted it.
7. Path Intellisense
Autocompletes file paths. That's it. That's the entire extension.
But oh, when you're importing from nested folders or linking assets, this saves so much time. No more typos. No more wondering if the path is `../utils` or `../../utils`.
This is one of those extensions that's so small you forget it's there, until you use VS Code on a fresh install without it and suddenly everything is slower.
8. Thunder Client Alternative – Peacock
Okay, this one's different. Peacock colors your VS Code window. Each project gets a different color. Sounds cosmetic? It prevents switching branches in the wrong window.
I've made commits to the wrong branch. Once. Peacock ensures that doesn't happen again because I always *see* which project I'm in at a glance.
The Language-Specific Essentials
9. Pylance (Python) or TypeScript Vue (Vue.js)
These aren't universal. But depending on your stack, they're essential.
Pylance for Python development gives you type hints, intelligent autocomplete, and faster linting. If you're doing data science or backend Python work, it's non-negotiable.
For JavaScript/TypeScript, VS Code has built-in support, but if you're using Vue, Svelte, or Astro, you'll want language-specific extensions. The generic TypeScript support isn't enough for template syntax inside single-file components.
Real talk: language support varies wildly. Rust has Rust Analyzer and it's phenomenal. Go has similar quality tools. But some newer languages have poor VS Code integration. Check your language's GitHub issues before committing to it.
10. Docker (if you containerize anything)
If you work with Docker at all, this extension is tremendous. Manages containers, images, registries—all from VS Code. No more terminal commands for common tasks.
I know some developers who refuse to use it because "you should learn the CLI." Fair point. But I learn the CLI *and* use the GUI extension because speed matters when you're debugging a container issue at 11 PM.
| Extension | Primary Use | Cost | Learning Curve |
|---|---|---|---|
| Prettier | Code formatting | Free | None—works on save |
| ESLint | Code linting | Free | Low—initial config |
| GitLens | Git history | Free (Pro available) | None—just hover |
| GitHub Copilot | AI code completion | $10/month | None—works automatically |
| Thunder Client | API testing | Free (Pro available) | Low—familiar interface |
| Docker | Container management | Free | Medium—Docker knowledge needed |
The Extensions I Removed (and Why)
Bracket Pair Colorizer 2: It was slow. VS Code now has native bracket pair colorization. Uninstalled.
Live Share: Cool concept. In practice, for remote pairing, I just screenshare and let them navigate. Faster than setting up sessions.
Indent Rainbow: Made code harder to read for me personally. Beautiful for some people. Clutter for me.
The lesson? Not every popular extension is for you. Install, test for a week, delete if it doesn't actually save time.
My Take
I went into this thinking I'd find 10 perfect extensions. Instead, I realized the "best" setup is deeply personal.
What surprised me: the free extensions often outshine paid alternatives. Prettier, ESLint, Path Intellisense—all free and better than their commercial competitors.
What disappointed me: extension bloat. People install 50 extensions and then complain VS Code is slow. It's not VS Code. It's the extensions. Start with 3-5, add more only when you feel friction.
Who should actually use all 10? Full-stack developers working in teams using modern JavaScript, Python, and Docker. If you're a frontend-only developer, you probably need 4-5. If you're writing embedded C++, your list looks completely different.
The real skill isn't knowing which extensions exist. It's knowing when to install one (to reduce friction) versus when to learn the CLI (to understand what's happening).
Verdict
Install Prettier, ESLint, GitLens, and Path Intellisense first. Those four cover 80% of daily developer needs and are nearly universal.
Then add based on your stack: GitHub Copilot if you code professionally, Thunder Client if you build APIs, Docker if you containerize, and language-specific extensions for your main language.
Everything else? Test it. Give it two weeks. If you don't miss it when you uninstall it, you didn't need it.
VS Code's real power isn't in extensions. It's in the editor itself. Extensions should enhance that. If they're slowing you down or creating complexity, they're the wrong extensions—no matter how popular they are.
Published by Dattatray Dagale • 09 September 2026
0 Comments