Why I moved to Neovim. And ditched VS Code/IntelliJ

#neovim #vim #vscode #productivity

I've been using VS Code and IntelliJ as my main editors for quite a long time, moving from Sublime Text and Atom. VS Code/IntelliJ immediately remind me of the time when we didn't have better alternatives for modern development workflows.

Apart from being widely adopted and having massive plugin ecosystems, VS Code and IntelliJ have some issues that can be easily fixed with a "more modern" (or rather, "timeless") alternative.

I've recently started using Neovim (along with tmux), and it does have many advantages compared to traditional IDEs. And FYI, the amazing Linux distribution, Omacom, comes directly with Neovim.

First of all, it's very fast! (Neovim, with its terminal-based interface, starts instantly compared to VS Code/IntelliJ). Editing code has been a real pleasure. The startup time and file switching are considerably faster.

Then, it keeps you focused on the essential, whereas VS Code/IntelliJ don't do this at all. With traditional IDEs, each time you need to switch context, you're moving between windows, tabs, and panels. This leads to constant distraction and context switching. Furthermore, you will still need to use your mouse frequently for navigation. In addition, there is always the temptation to install "just one more extension" that slows everything down (Neovim keeps you in the terminal with keyboard-driven workflows).

Neovim (and a few others such as [Helix](https://github.com/helix-editor/helix) that can also be used as modern modal editors) handle this under the hood. This way, when you are dealing with multiple projects and terminal sessions, you won't have any bad surprises like slow startups or high CPU/memory usage, for instance.

For instance, here's my typical workflow:

# Terminal session with tmux
tmux new -s coding
nvim .
# Everything happens here (editing, git, terminals, all keyboard-driven)

With Neovim, I stay in the terminal where everything I need is right there. You can also (and very easily) start using Neovim in your existing projects without changing anything. At the end of the day, it's just a text editor that works with any codebase.

-- Example Neovim config (init.lua)
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.tabstop = 2
vim.opt.shiftwidth = 2

-- Using lazy.nvim for plugin management
require("lazy").setup({
  "nvim-telescope/telescope.nvim",
  "neovim/nvim-lspconfig",
  "hrsh7th/nvim-cmp",
})

It's also good to mention that Neovim is fully compatible with Vim plugins while adding modern features like LSP support, tree-sitter, and Lua configuration.

Downsides

The only case where you should still use VS Code/IntelliJ is when you're just starting out in programming. This occurs either when you're learning to code or working in a team that requires specific IDE features. The problem is that Neovim has a steep learning curve initially. We need time to learn modal editing and configure everything, such as LSP servers, formatters, and keybindings that don't come pre-configured.

However, for experienced developers who value speed and efficiency, Neovim is the clear winner. Anyway, it's worth trying it for a week or two 😉

Now, it will give a significant boost to your productivity and focus, as well as better resource usage on your machine, which is the most important at the end of the day, right? 😊

Alternatives

Helix is another modal editor option (still relatively new and not very popular either), that provides a similar experience to Neovim. It also offers modern features out of the box, but it uses a different selection-first model and has fewer plugins available compared to Neovim's mature ecosystem.

When to still use VS Code/IntelliJ

Lastly (although you might not need this), it's good to mention that VS Code/IntelliJ are still perfectly valid for beginners, pair programming sessions (where screen sharing GUI is helpful), or teams with standardized IDE setups that require specific extensions and configurations.