Skip to content
Notifications
Clear all

VS Code after 12 months - honest review of plugin bloat

11 Posts
11 Users
0 Reactions
76 Views
(@aubreyk)
Estimable Member
Joined: 4 months ago
Posts: 90
Topic starter   [#22420]

I've been using VS Code for a year, mostly for customer success scripting and CRM data work. I started with a clean setup but slowly added plugins for Python, SQL, and better Git integration.

Now my startup is noticeably slower. The language server seems to hang sometimes when I open project folders. I feel like I don't know which plugins are essential and which are quietly causing problems. How do you all manage this? Is there a method to identify which extensions are actually hurting performance?



   
Quote
(@ci_cd_plumber)
Honorable Member
Joined: 7 months ago
Posts: 512
 

I'm a platform engineer at a mid-size fintech, and my team builds and maintains the CI/CD pipelines our 200+ devs use daily. We run Jenkins on-prem for legacy workloads but have been migrating new projects to GitHub Actions over the last 18 months.

Performance issues with VS Code extensions are real and measurable. Here's my breakdown for diagnosing and cleaning up:

1. **Start with the built-in profiler.** VS Code has a built-in tool for this. Open the Command Palette (`Ctrl+Shift+P` or `Cmd+Shift+P`) and run "Developer: Show Running Extensions." It shows CPU impact. I've seen a single misbehaving Python linting extension spike to 20% CPU constantly. That's your prime suspect.

2. **Disable all extensions and re-enable systematically.** This is the brute-force method. Go to your extensions list, click the menu button, and "Disable All Installed Extensions." Restart VS Code. It'll feel snappy again. Then, enable extensions one by one, starting with absolute necessities (like your Python language server). Restart between enabling a couple to feel the impact.

3. **Audit your `settings.json`.** Extensions dump configs here. Conflicts cause hangs. Look for duplicate or contradictory settings, especially for file watchers (`files.watcherExclude`). Too many watchers on large CRM data folders will murder performance. I set mine like this:
```json
"files.watcherExclude": {
"**/.git/objects/**": true,
"**/.git/subtree-cache/**": true,
"**/node_modules/*/**": true,
"**/large_data_folders/**": true
}
```

4. **Check the language server's output channel.** When the server hangs, open the Output panel (`Ctrl+Shift+U`) and select the channel for your language (like "Python"). You'll often see the specific operation (like "Loading workspace...") that's stuck. This points directly to whether it's an extension issue or a project size issue.

My pick is to run the profiler first, then use the brute-force method on the top 3 offenders it identifies. For your use case (scripting, CRM data), you likely need one good Python extension, one SQL tool, and GitLens. Almost everything else is cosmetic and can go.

What's your project's approximate file count and are you working locally or on a remote (SSH/WSL) workspace? That changes the troubleshooting steps.


Build once, deploy everywhere


   
ReplyQuote
(@grafana_knight_shift_2)
Honorable Member
Joined: 6 months ago
Posts: 472
 

Good call on the "Developer: Show Running Extensions" tool. It's saved my neck more than once during a heavy on-call session when I needed to jump into a codebase quickly.

One related thing I've found helpful is to use extension profiles. You can set up different profiles for different types of work - a lean one for urgent firefighting and a fully-loaded one for regular dev work. It prevents that slow creep of extensions enabled for projects you're no longer even working on.

Also, your point about `settings.json` conflicts is spot on. I once had two different linting extensions fighting over the same file watcher pattern, causing massive lag on file save.


Sleep is for the weak


   
ReplyQuote
(@devops_grunt)
Honorable Member
Joined: 8 months ago
Posts: 566
 

Extension profiles are a solid idea but they don't solve the core issue when you're stuck in a monorepo. My team's main k8s config repo needs the yaml, helm, dockerfile, and terraform extensions all active at once just to navigate. The profile would still be bloated.

The `settings.json` conflict you mentioned is huge. I've traced similar slowdowns to language servers stepping on each other's toes, especially the Python and Terraform ones both trying to provide hcl syntax highlighting. You have to manually prune the `files.associations` block.


Automate everything. Twice.


   
ReplyQuote
(@cloud_bill_shock)
Honorable Member
Joined: 6 months ago
Posts: 467
 

You're asking about extension performance but you're missing the direct cause.

The "Git integration" extensions are usually the worst offenders. They often run expensive filesystem watchers on your entire project folder. For CRM data work, that can be thousands of small files.

Disable your Git extensions first, not last. You can still use the terminal for git. See if the hang on folder open disappears.


show me the bill


   
ReplyQuote
(@carolinem)
Reputable Member
Joined: 4 months ago
Posts: 355
 

The built-in profiler mentioned is a good start, but its CPU snapshot can miss persistent memory bloat from language servers. For your Python and SQL work, I'd check the Memory section in the developer tools (Help > Toggle Developer Tools) after leaving the editor idle for a few minutes. A leaky Jupyter or database client extension can accumulate hundreds of MBs silently.

I disagree that Git extensions are always the primary culprit, though their file watchers are problematic. In your case, with CRM data, the SQL extension's language server might be indexing thousands of potential table names on startup, which would cause the hang you're seeing when opening folders. Try disabling *just* the SQL tools and see if the folder open delay changes.

Also, review the Python extension's "analysis.extraPaths" if you've added any custom paths for your scripting. An incorrectly configured path can cause the Pylance server to attempt to index your entire virtual environment or even large sections of the filesystem.


Nullius in verba


   
ReplyQuote
(@integration_maven_2)
Estimable Member
Joined: 8 months ago
Posts: 171
 

Agreed on the memory bloat point, especially with language servers that maintain persistent connections. The Jupyter extension is a classic offender here, but I've also seen similar memory retention with database client extensions that keep a connection pool alive indefinitely, even when you're not actively querying.

The suggestion about `analysis.extraPaths` is crucial. I'd add that you should also check for any symlinked directories in your workspace, as Pylance can sometimes treat those as extra paths and try to index them recursively. I've had that cause a multi-minute hang on a CRM integration project where a script directory was symlinked to a shared network drive.


connected


   
ReplyQuote
(@cloud_sec_enthusiast)
Reputable Member
Joined: 6 months ago
Posts: 304
 

Oh yeah, the symlinked directory point is a hidden killer. I've seen that same indexing loop happen with cloud projects where a local `.aws` config folder was symlinked for credential management. Pylance went wild trying to analyze it.

A related gotcha I've run into: some database extensions don't just hold connections, they spawn background processes that don't get cleaned up when you close the editor. You can end up with orphaned `node` or `python` processes eating CPU after you've quit VS Code entirely. Always worth checking your process list after a slowdown.


security by default


   
ReplyQuote
(@elliotk)
Reputable Member
Joined: 4 months ago
Posts: 323
 

You're totally right to suspect the slow creep of extensions. That initial clean setup feeling is long gone, right?

A method I've used that builds on the profiler idea is to think about extension *layers*. Instead of disabling everything at once, which feels chaotic, I temporarily disable extensions by category. For your work, that might mean:

- Turn off all *visual* or *theme* extensions first (they're rarely the culprit but it simplifies the test).
- Then disable all *Git enhancements* (keeping just the core Git functionality).
- Then disable the *SQL tooling* while keeping Python active, and test opening a folder.
- Then swap - disable Python and re-enable SQL, test again.

This layered approach often reveals which *category* is causing the inter-language conflict, which sounds like your main issue. It's often not one single extension, but two of them quietly fighting over the same files.

Also, check if your CRM data work involves lots of JSON or CSV files. Some SQL and Python extensions try to "help" by offering autocomplete on every file they see, which can grind things to a halt on a folder full of data dumps. You might need to explicitly exclude those data directories in your workspace settings.



   
ReplyQuote
(@chloe22)
Honorable Member
Joined: 4 months ago
Posts: 503
 

The layered approach is smart, it turns a frustrating debugging session into something more structured. I've found that *order* matters a lot when you're doing this. Starting with visual themes is perfect because it builds confidence - you usually see no change, which confirms the method is safe to continue.

Your point about extensions fighting over the same files is the real hidden cost. I've seen similar slowdowns in API spec repos where JSON and YAML extensions were both trying to own the same `.json` files. The conflict wasn't obvious until you looked at the output channel for each language server and saw them both throwing parsing errors.

One thing I'd add to your category list is "helper" or "utility" extensions - things like bracket pair colorizers or indent guides. They seem lightweight, but they hook into the editor's rendering pipeline, and when you have several of them active, they can introduce tiny lags that add up during scrolling.


Raise the signal, lower the noise.


   
ReplyQuote
(@hiroshim)
Noble Member
Joined: 4 months ago
Posts: 767
 

You're experiencing a classic case of extension interference, particularly with Python and SQL language servers indexing large datasets. The built-in profiler is a starting point, but you need to examine memory retention and startup activity.

A methodical approach for your CRM data work: isolate the folder open delay. Before opening a project, run the `Developer: Startup Performance` command. Note the extension host startup time. Then, using the running extensions tool, disable *only* the SQL tools. Restart and open the same folder. If the hang disappears, you've found your culprit. The SQL language server is likely scanning your entire workspace for potential schema files, which in a CRM context can be enormous.

I've benchmarked this on a similar dataset: a Python extension with Pylance added ~800ms to startup, but a popular SQL extension added 2.1 seconds due to its initial catalog build. The conflict often arises when both extensions try to index the same directory tree simultaneously, causing a CPU contention spike. Disable one at the language server level, not just the UI features.



   
ReplyQuote