Why I Switched from VS Code to Neovim: My Journey as a Beginner

Introduction

As beginners, we are often told to use VS Code because it’s easy to use, highly extensible, and powerful with the right extensions. And for the most part, this is true. But as I progressed in my development journey, I realized that VS Code’s resource usage was becoming a bottleneck especially when working on a resource-intensive project.

That’s when I decided to switch to Neovim. This wasn’t just out of curiosity but out of necessity. Here’s my journey, the challenges I faced, and why I believe this was one of the best decisions I’ve made.

How I Discovered Neovim

I first heard about Neovim through ThePrimeagen, a Netflix senior developer and a strong advocate for Neovim. Watching his videos, I was fascinated by how effortlessly he navigated through files and edited code at lightning speed.

However, at that time, I didn’t have a compelling reason to switch. Neovim looked impressive, but VS Code was working fine—until my final year project changed everything.

Why I Finally Switched

I am currently working on a mobile app with a Flask backend for my final year project. The backend has grown quite heavy with multiple features, and since I am developing the frontend with Expo, my laptop has to compile the app locally.

This caused serious performance issues:

- VS Code became laggy and unresponsive while the app was running.

- If the app crashed, I had to restart everything, which made VS Code freeze.

- VS Code itself is resource-intensive, which affected my backends' performance.

Since I was already using Linux for backend development, I thought, Why not switch to a lightweight editor like Neovim?

My First Steps with Neovim

When researching how to get started, I found that many recommended learning Vim motions first on an existing editor before transitioning to Neovim. But I didn’t have that luxury—I wasn’t switching for fun, but out of necessity.

At first, I considered using a Neovim distribution (preconfigured setups), but then I thought, That would be too easy! I wanted to fully understand what I was using. So, I decided to start with kickstart.nvim—a minimal setup that provides a foundation while allowing customization.

The Challenges of Switching

I won’t lie—the transition was frustrating. Unlike VS Code, where you simply install extensions and everything "just works," Neovim requires manual setup for:

- Language servers

- Auto-completion

- Auto-formatting

- Linting

Even with kickstart.nvim’s documentation, setting everything up was a challenge. I had to learn Lua, the scripting language used for Neovim configurations, just to understand how things worked.

To ease my transition, I started by configuring Neovim only for Python, since I was already proficient in it and didn’t need too much help from auto-completion.

The Learning Curve

The hardest part? Vim key bindings.

- Navigating with j and k instead of arrow keys.

- Switching between Insert mode and Normal mode.

- Copying, pasting, and deleting text efficiently.

I had to retrain my muscle memory, which made me much slower at first. However, I followed a tip from experienced Neovim users:

\> "Focus on what you know rather than trying to be optimal immediately."

Even if something could be done with fewer keystrokes, I first learned the longer way to understand why things worked that way.

To help myself, I:

- Created a document with all essential key bindings.

- Watched multiple tutorials from different creators.

- Adapted my workflow based on what worked best for me.

Two Months Later: Was It Worth It?

Now that I’ve used Neovim for over two months, I can confidently say that switching was one of the best decisions I’ve made for my coding workflow.

What Improved?

✅ Faster navigation & editing – I can switch between files and edit text much faster than before.

✅ Deeper understanding of development tools – I learned about LSPs, auto-completion, formatters, and linters in-depth because I had to configure them manually.

✅ Better habit of reading documentation – Many beginners skip this and rely on tutorials, but setting up Neovim forced me to read multiple official docs.

What Do I Miss From VS Code?

🚫 Multi-cursor editing – Neovim doesn’t have this natively; you can achieve similar results using macros or regex, but it requires extra thinking.

🚫 Integrated tools – VS Code has built-in support for tools like Postman and MongoDB, whereas in Neovim, you need to use separate terminal commands.

Advice for Beginners Considering Neovim

If you’re thinking of switching to Neovim, don’t jump in blindly like I did. Instead, I recommend:

1. First, learn Vim motions – These will significantly boost your productivity, even if you stay in VS Code.

2. Start with a basic configuration – Something like kickstart.nvim can help ease the transition.

3. Be patient – The learning curve is steep, but once you get the hang of it, it’s incredibly rewarding.

Final Thoughts

While Neovim isn’t for everyone, it was the right choice for me. It solved my performance issues, made me a more efficient developer, and gave me a deeper understanding of how development tools work.

If you’re struggling with VS Code’s resource usage or want to explore a keyboard-driven workflow, Neovim is definitely worth a try!

Would you consider switching to Neovim? Or have you already tried it? Let me know in the comments!