Every Developer Should Try Vim

What is Vim?

Vim is a highly efficient, keyboard-driven text editor that prioritizes speed, precision, and control. It’s been around for decades, but it’s far from outdated. In recent years, Vim has seen a resurgence, thanks largely to Neovim, a modern refactor of Vim that brings a faster core, better plugin support, and a vibrant, forward-looking community.

Many developers avoid Vim because of its steep learning curve and unfamiliar interface. But that’s changing, as Vim’s community has grown rapidly. This shows that other developers are seeing Vim as a serious upgrade to their workflow. Of course, it can be said that these developers just don't know how to quit Vim.
Luckily for us, someone has taken the time to compile a list of ways to exit Vim. I've ultimately chosen for The Acceptance Way.

You do not need to use Vim directly in your terminal, most modern editors have a Vim plugin so that you can keep using the editor you are familiar with and get the benefits of Vim. This saves you hours of configuration and makes the barrier to get started much lower.

Why use Vim?

Vim isn’t just an editor, it’s a mindset. I've started to use Vim because it offers unmatched speed, muscle-memory efficiency, and a sense of flow that’s hard to replicate. You're no longer using your mouse or the arrow keys to navigate, you're using your keyboard to go blazing fast.

At its core, Vim is a modal editor which is a little different than regular editors. It means you switch between modes and each mode has its own use cases. The modes in Vim are:

• Normal mode – for moving around and making changes

• Insert mode – for typing text

• Visual mode – for selecting and manipulating blocks

• Command mode – for things like saving, quitting, or searching

In a regular editor you would only have insert mode. This separation of concerns sounds odd at first, but it allows you to perform complex edits with just a few keystrokes. Once it clicks, it’s hard to go back.

Here are a few examples that show how Vim feels in action, these are all executed in normal mode:

1. dd – delete the current line

2. 5yy – copy 5 lines starting from the current one

3. di{ – delete everything inside the nearest {} block

4. ci( - change inside the nearest ()

Learning Vim is hard

I've personally struggled with learning Vim, it was intimidating at first. The reason for this is that modal editing was unfamiliar for me and I was so used to my previous JetBrains editor and its functions that I had a hard time being productive. I admit, the first time I tried it I gave up. To really get started learning Vim you have to change your mindset about how you write code, and that's hard after all these years of programming.

I didn't understand it well enough, I knew how to get into insert mode and use :wq to exit. With that little skill in Vim it feels cumbersome and slow to use. I hadn't even found out about Vimtutor, if you don't know, Vimtutor is a tool that teaches you the basics of Vim in about 20-30 minutes.

But there is a light at the end of the tunnel! As with any new skill, it's only hard at the beginning. If you can push through the initial awkwardness, you unlock a tool that grows with you for the rest of your career. And you will be able to say: "I use Vim by the way".

Start in your own editor

As I started learning more things about Vim using tools like Vimtutor and YouTube videos I decided that I would give it another go. Instead of using Neovim I installed Ideavim. This allowed me to get started with Vim in an environment that I was comfortable with. The first weeks were slow, I felt like my productivity had declined by 50%. But after that initial drop I noticed that I got faster, things started to feel natural and became muscle memory.

I no longer had to think about how to do something. My fingers just knew. That’s when Vim clicked for me, not as a tool I was forcing myself to use, but as an extension of how I write code. It really gives you an extra dimension of editing code.

Looking back, that short period of pain was more than worth it. Vim didn’t just change my editor, it changed how I like to write code. And that shift has made programming feel smoother, faster, and most importantly, a lot more fun.

The nice thing with Vim is that you keep learning, you keep finding ways to get faster. There is even a website called VimGolf that has challenges for users to do certain tasks with as few keystrokes as possible.

I stuck with my JetBrains editor and Ideavim for two years. After those two years I decided that I wanted to dig deeper, customize my editor more and really get the experience that I liked.

Switching to Neovim

The switch was hard at first, especially file management. I was so used to the file tree on the left of my editor. I tried to replicate that in Neovim with nvim-tree but it didn't feel the same. Until I came across oil.nvim, this was a game changer for me as it made creating, renaming and moving so much easier. That was the moment that I felt I could switch. I had tried a few of the popular Neovim distros such as Lunarvim but found them too overwhelming.
I personally prefer a basic setup with not too many bells and whistles (I know, I used JetBrains before but only used 10% of that editor's capacity and had a minimal interface configured).

I did not start with a blank Neovim install, I used kickstart.nvim. It has such clear documentation which made it really easy to understand and get started. This YouTube playlist by TJ DeVries also helped me a lot to get started.

It amazed me how limiting the JetBrains + Ideavim actually was, with Neovim it is so much easier to set up custom and more advanced keybinds using Lua.

Final Thoughts

Learning Vim isn’t just about picking up a new editor, it’s about changing how you interact with code. I believe that every developer should at least try Vim to see if it fits them. If you stick with it, Vim rewards you with a sense of control and fluency that’s hard to describe until you experience it yourself.

You don’t have to go all-in on day one. Start where you are. Use a plugin in your current editor, explore Vimtutor, or just commit to learning a few motions at a time. You’ll be amazed how much power you can unlock with just a handful of commands.

Vim won’t make you a better developer overnight, but it will change the way you think about writing code. And once it clicks, it becomes something you don’t want to work without.