Why I Switched to (neo)VIM as my Primary IDE
* I am going to use VIM and neovim interchangeably in this article. I use neovim as a daily driver.
I have been cringing pretty hard at the onslaught of “I Switched to Linux” or “10 VIM Tricks for Noobs” videos on YouTube. However, upon reflecting on this knee jerk reaction, I realized that the sudden influx of more people switching to Linux is exactly what I have been evangelizing for for years. Instead of looking down from my Artix ivory tower, I decided to partake in the trend as a celebration of the newcomers to Linux.
Completely switching to VIM has been a goal of mine for a few years now. Because I have always managed servers (personally and at work), I was already acquainted with VIM as a text editor. While I was not proficient in VIM motions, I was able to use VIM keys, enter and exit INSERT mode as well as quit VIM the coolest way possible (ZZ).
When I first started thinking about switching to VIM, I must admit there was a coolness factor involved. I wanted to use the software the developers I looked up to used. I had tried to switch to neovim a few times in the past. The biggest stumbling block for me came from installing bootstrapped neovim setups like LazyVIM or NvChad. While these setups came with a ton of (mostly) useful features, they thrust me into a new environment with tons of keybindings that–not only did I not understand–were not actually set up by me in a way that made sense personally. This resulted in failed frustrated attempts at switching completely and then shamefully crawl back to my IDE of choice, PyCharm by JetBrains.
PyCharm became a major sticking point for me philosophically. I had already switched to a light-weight linux distribution with i3wm as my window manager. All of the other programs I used on a daily basis were light-weight with a flavor of Diet Suckless. While PyCharm did have an open-source community edition, it definitely lacks in features and it is pretty much a Python only IDE, i.e. no other LSPs for other languages (besides maybe HTML). I was not about to shill out $300/year for PyCharm Pro.
On top of all of this, PyCharm was not effective on my work machine. I pretty much had to use VSCode. So now I was faced with the task of learning VSCode as an IDE, as well as maintaining both IDEs simultaneously. I was not going to install VSCode on my personal computer as that was even more incongruent with my moral standards. The choice was obvious, adopt VIM as my main IDE, or perish (metaphorically/morally).
It was not about being “cool” anymore, and while the performance increase when it came to coding speed/simplicity was evident, the main reason I switched to VIM was in order to maintain a consistent development environment across all devices for the foreseeable future. Barring some weird turn of events, we can assume VIM is not going anywhere (It is literally the same age as me, being released in January 1992, and going as strong as ever).
The other benefit of using software like this is that we can assume that it will not change in a significant way. Even if it does change, there will be configuration options to maintain it in the form that is suitable for my needs. The same thing can not be said about modern IDEs, which are maimed at will by the large corporations that control them.
Modern IDEs are an abomination, they:
- are memory hogs (even looking at a destkop shortcut of a modern IDE causes my fan to turn on)
- use telemetry to track what you are coding, and who knows what else.
- foster a uselessness in developers by providing GUI options for things like version control, compiling, docker, cloud integration, etc.
- integrate LLMs, which further fosters a uselessness in developers who would rather outsource the act of thought itself, as well as the art of software development to a data center. (Essentially automating their jobs away [this will not happen by the way, but is a different topic for a different blog post])
But all of these issues come secondary to the necessity of having a simple, stable, repeatable, and everlasting development environment across all of my devices. I am a software developer. I care about writing software. I need a tool that provides the least amount of friction for me to execute my craft. After almost a year, it is apparent VIM is the best tool for the job (for me at least).
Returning to the topic of neovim configuration and bootstrapped setups like LazyVim. I settled on using Kickstart NVIM at first. Which is a bootstrapped configuration file created by TJ DeVries who has a YouTube video explaining in detail how to set it up and it’s features. While I think Kickstart is a good place to start, I have moved away from it in favor of my own configuration for a few reasons:
- Kickstart still provides a bunch of plugins up front and you need to take the time to learn them.
- You are given a large configuration file that you need to become acquainted with in order to make changes (TJ does a good job at documenting the file, so this is not a fault on his part), and by the time you have learned how the config file works, you may as well have just created your own personal configuration file.
- Kickstart uses Lazy as a package manager, but neovim now has a native package manager built in as of v0.12. I would rather use the native package manager.
You can see my config file here. (Yeah I still use plugins and Mason to handle my LSPs, don’t hate on me plz).
