My VS Code setup went from 47 extensions to 6. My productivity went up.

I counted my VS Code extensions. There were 47. My editor took 8 seconds to start, lagged when I typed, and crashed once a week. I disabled 41 of them and kept 6. Here is what happened.

The problem

Extension creep is gradual. You install a formatter, then a linter, then a theme, then a snippet pack, then a language support extension for a framework you tried once and never used again. Each one seems small. Each one adds startup time, memory usage, and editor complexity.

My 47 extensions included:

• 5 formatters (Prettier, ESLint, Stylelint, Beautify, Rustfmt)
• 4 language packs (Python, Go, Rust, Java, only Python was active)
• 3 themes (one in use, two installed "to try later")
• 6 snippet packs (React, Vue, Python, Docker, Git, and a generic HTML one)
• 4 Git extensions (GitLens, Git Graph, GitHub Pull Requests, Git History)
• 3 AI extensions (GitHub Copilot, Codeium, Tabnine, all disabled in favor of Cursor)
• 22 others (Docker, YAML, TOML, markdown preview, CSV viewer, path intellisense, import cost, indent rainbow, bracket pair colorizer, and more)

Most of these I had installed once and forgotten about. They were running on every startup, consuming memory, registering commands, and contributing to the status bar.

What I kept

I went through each extension and asked: "Have I used this in the last week?" If the answer was no, I disabled it. Here is what survived:

1. Prettier. Code formatting. I use it on every file. Non-negotiable.

2. ESLint. Linting. Same as Prettier, I use it constantly. The two work together.

3. GitLens. I use the blame and diff features daily. The rest of GitLens (code lens, file history, commit search) I could live without, but the blame view alone justifies the extension.

4. Astro. Language support for Astro, which is my primary framework. Without it, .astro files are unstyled HTML.

5. Tailwind CSS IntelliSense. Autocomplete for Tailwind classes. I write Tailwind every day. Without this, I am guessing at class names.

6. Error Lens. Shows errors and warnings inline instead of requiring a hover. It is a small UX improvement that saves me hundreds of micro-interactions per day.

That is it. Six extensions.

What happened

Startup time: 8 seconds to 1.5 seconds. The difference is immediately noticeable. I open and close the editor many times a day, and the 6.5 second saving compounds.

Memory usage: 1.2 GB to 380 MB. VS Code went from being the heaviest application on my machine to being lighter than my browser. The lag when typing in large files disappeared.

Crashes: once a week to zero in six weeks. I cannot prove causation, but the correlation is strong. Extension conflicts are a known cause of VS Code instability, and removing 41 of them eliminated a lot of potential conflicts.

Productivity: up, measurably. I was spending time managing extensions: updating them, configuring them, disabling ones that conflicted, and debugging issues caused by interaction between them. That time is gone. The editor does what I need and gets out of the way.

What I learned about extension creep

Extensions are not free. Each one adds to startup time, memory footprint, and editor complexity. The cost is invisible until you remove them and feel the difference.

You do not use most of your extensions. 41 out of 47 had not been used in the last week. Some had not been used in months. They were running anyway.

The best extensions are the ones you forget you have. Prettier, ESLint, Error Lens: these work silently. They do not have popups, side panels, or status bar clutter. They do their job and disappear.

AI extensions are redundant when you use an AI editor. I was running Copilot, Codeium, and Tabnine inside VS Code while also using Cursor (which has its own AI). The AI extensions were disabled but still loaded. Removing them freed memory and removed a source of confusion about which AI was active.

The 2026 editor landscape

The choice in 2026 is not "which extensions should I install." It is "which editor should I use." The landscape:

• VS Code remains the default. The extension ecosystem is the largest. With a minimal setup, it is fast and reliable.
• Cursor is VS Code with AI built in. If you are paying for an AI assistant, Cursor replaces the need for AI extensions.
• Zed is the performance option. Rust-native, fast startup, built-in collaboration. Smaller extension ecosystem.
• JetBrains (WebStorm, IntelliJ) is the heavy option. Built-in tooling for everything, but higher memory footprint and per-seat licensing.

My current setup is Cursor (which is VS Code under the hood) with the same 6 extensions. The AI features are built into the editor, so I do not need AI extensions. The 6 extensions I kept are the ones that do work the AI cannot do: format my code, lint it, show Astro syntax, autocomplete Tailwind classes, and display errors inline.

If you want to try this

1. Open your extensions tab. Sort by "installed."
2. For each extension, ask: "Have I used this in the last week?"
3. Disable everything where the answer is no. Do not uninstall yet, just disable.
4. Work for a week. If you need an extension you disabled, re-enable it.
5. After a week, uninstall everything that is still disabled.
6. Measure your startup time before and after. The difference is your motivation to keep it lean.

The temptation to install will return. Every blog post about "10 VS Code extensions you must have" will add to your list. The discipline is not "never install." It is "install, try, and remove if you do not use it within a week."