If you’ll enjoy reading this post and would like to stay in touch, please subscribe to my newsletter.
Hope you enjoy the read, let me know what you think about it in the comment below or get in touch on Twitter,
Tom
Optimal configuration for a coding editor is a tricky thing. On the one hand, you want your main working tool to stay lean and fast; on the other hand, there are many cool things out there you might want to try. Have too little, and you are missing out on an opportunity to enhance your workflow. Add too much, and you end up with slow startup times, lower performance, and random things ruining your focus. All of which leads to miserable development experience. When you reach this point, you know that Plugin Creep already set in.
What is Plugin Creep?
Plugin Creep occurs when you keep adding new plugins/extensions to your editor. It’s a gradual process that turns your editor into a resource-hungry, hard-to-work-with, and difficult-to-maintain mess. Plugin Creep can affect any software. When writing this post, I noticed the term used in one of the WordPress communities. WordPress is known for the millions of plugins you can use to handle anything you need. It’s also known for getting extremely slow—surprisingly fast. The regression is proportional to the number of plugins you install.
Why does it happen?
Here are the most common reasons why Plugin Creep happens:
Resource Consumption: Each plugin, regardless of size, requires some amount of memory and processing power to function. As the number of plugins increases, this cumulative demand strains your system.
Code Overhead: Plugins are essentially extra code that your editor needs to load and execute. This introduces overhead, especially with poorly optimized plugins, leading to slower startup times and potential lag during editing.
Compatibility Conflicts: Plugins aren’t always designed to work perfectly together. They might interfere with each other’s code or compete for the same resources, leading to unexpected errors, crashes, or strange behavior within your editor.
Dependency Issues: Some plugins rely on specific versions of other libraries or software components. Over time, as plugins and dependencies update, maintaining a compatible and functional setup becomes a complex juggling act.
As you can see, Plugin Creep is mainly a problem of accumulation. A single plugin will have negligible impact, but the combined effect of multiple plugins adds up. Each plugin brings its own resource demands and potential conflicts.
Why Plugin Creep is Dangerous
Plugin Creep can quickly snowball into a serious issue. If you keep it unchecked, it can seriously hinder your productivity. Here’s how:
Performance Degradation: Each plugin adds to the overall resource consumption of your editor. Over time, this can lead to slow startup times, lag during editing, and even crashes, especially on machines with limited resources.
Stability Issues: Compatibility problems between plugins can lead to unexpected crashes, errors, or strange behavior in your editor. Debugging these issues can be time-consuming and derail your daily work.
Feature Fatigue: With a plethora of features at your fingertips, it’s easy to fall into the trap of “feature fatigue.” You might spend more time configuring than actually coding.
Maintenance Burden: Keeping plugins updated becomes a chore. New features might break compatibility with your current setup, and conflicts arise as plugins evolve independently.
You need your editor to be fast and sharp. Somebody might say that you won’t even notice a few milliseconds of difference in startup time, but it adds up. The slower your editor is, the easier it gets to get out of flow and lose your focus.
What can you do to avoid it
Here is a set of things you can do to avoid Plugin Creep.
Use built-in tools
Most modern editors come packed with powerful features under the hood. Before reaching for a plugin, you should at least try working with built-ins. Invest time into learning built-in features, reading documentation, and learning keybindings. The best way to avoid Plugin Creep is to eliminate the need to install new plugins.
You might be using the wrong editor
Sometimes it might be better to look for another editor. If you notice that your tool of choice wasn’t made with your workflow in mind, maybe there is something out there that will suit you better. A lot of problems people encounter when over-configuring software come from the fact that they try to make it what they would like it to be, and it might have never been designed to support their way of working in the first place.
Take your time to find tools that suit you and easily integrate into your workflow. Don’t use something only because everybody is doing it. Find your own way. You will be using those things daily – invest time into building your toolbox.
Audit things you install
Before hitting install, take a closer look at the plugin.
Review the opened issues. Are those being addressed? You don’t want to step on an issue that won’t ever be solved. It doesn’t mean that the plugin needs to be actively developed. Some of the best plugins I used had no new commits in the last 4–5 years. They just do the job, and there is no need to change them. You can rely on their stability.
What’s the development and user experience philosophy behind it? If you build the core of your workflow around a plugin that changes often, your workflow will be subject to frequent changes as well.
See what the community thinks about it. If there are no opinions about it, there is a high chance you are a beta tester, and as any pioneer, you will pay the price for it.
Focus on the problem
Before rushing to install plugins, step back and truly analyze the problem you’re facing. Is there a gap in your editor’s native functionality? Maybe you are missing something in your workflow. What if you wrote a simple function to do the job?
Clearly defining the core problem will help you determine if a plugin is truly the right answer, and it can guide you toward selecting the best solution rather than just piling on more features.
Don’t fix what’s not broken
If you have a mature workflow and tinkering around with your editor config isn’t your thing, it’s completely fine to just leave it alone. Don’t fix what is not broken. Even after I moved from Vim to Neovim, I used my old Vimscript-based config for years before rewriting it to Lua. It did the job fine and worked well.
Load plugins when they are needed
Many editors offer the ability to selectively load plugins. I don’t load most of my Neovim plugins on startup and only load them when I first use them. You can also load plugins per file type, or on certain events. This significantly reduces background overhead and can make a huge difference in your editor’s performance.
Prune your config
Your editor is a piece of software, and you should treat it as any other tool in your stack. When you notice it’s slowing down, don’t ignore it. Spend some time to see why and whether you can eliminate the problem. The sooner you do this, the better. Sometimes it will be as simple as updating plugins or removing the ones you no longer use.
If you let it accumulate, it will become this terrifying piece of mud you don’t really want to touch, and in extreme situations, you might need to declare editor config bankruptcy and start over.
Learn to debug your editor
Most modern editors offer amazing tools to debug their behavior and performance. It’s worth looking into it and learning how to debug yours. It’s equivalent to being able to do some small repairs around your car. You might not need it if you are a casual driver, but every professional truck driver will tell you it’s essential for their profession.
Final word
I’ve spent countless hours changing my Neovim config. When I first started to work in Vim, I learned the hard way that overloading it with plugins is a bad idea. Not only does it become slow, but you also end up not using most of it because your brain can only process a limited amount of new things at any time. I hope this article will help you avoid my mistakes.
