I Switched from VS Code to Neovim (And Why You Probably Shouldn't)

I've used VS Code since the start of my career. Comfortable. Autocomplete works, debugger integrates, extension ecosystem mature, git visual and clear. Friends used vim, I laughed at them - "why make it hard, you only live once." I said VS Code was enough, no need for a modal editor, no need for keyboard-only.

In 2023 I tried neovim on a whim. Not because I needed to. Not because "more productive." Curiosity. First 3 months: productivity dropped 50%. I quit twice. Now I'm 80% neovim, 20% VS Code (debugger, remote dev, pair programming).

This isn't a "vim is superior" article. This is an honest reflection - why I stuck with neovim despite the first 3 months being hell, what neovim wins at, what VS Code still wins at, and why you probably shouldn't switch.

---

Why I Tried

Not hype. 3 honest reasons:

1. I watched senior devs I respect. They use vim. Not all, but the fastest coders I know use vim. I thought: "what do they know that I don't?" Turns out - muscle memory. They don't think "how to navigate", they do navigation reflexively. Unlike me who still thinks "what's the shortcut to jump to function."

2. SSH workflow. I SSH into servers often. Default vim on the server. Every time I debugged production, I struggled with basic vim. I thought: "if I were good at vim, server debugging wouldn't be painful."

3. RSI (repetitive strain injury). I started feeling wrist pain. Constant mouse use, constant trackpad reaching. I read that keyboard-centric editors could reduce strain. Curiosity + health reason = enough reason to try.

Reasons that didn't factor in:
• "Vim makes you look pro" - ego, skip
• "VS Code is bloated" - true but that's a side effect, not a reason
• "Modal editing is faster" - unproven for me at the time

---

First 3 Months: Hell That Made Me Quit Twice

I won't sugar-coat it. The transition was painful. Productivity dropped. Ego dropped. I, who felt like a good coder, looked like a beginner.

Weeks 1-2: Vim tutor + basic keybindings.

I ran vimtutor 3x. Learned hjkl, w, b, e, i, a, o, d, y, p. Modal editing concept: normal mode, insert mode, visual mode. For me, used to "click, type, click" - trapped. Every edit, I had to think "enter insert mode first, type, back to normal mode." High cognitive load.

" What I used in week 1:
i " insert mode (type)
Esc " back to normal mode
:wq " save & quit
dd " delete line
yy " yank line
p " paste
/keyword " search
n / N " next / previous search

8 keybindings. But every time I wanted to write, I had to do 3 steps (enter insert, type, back to normal). VS Code: just click and type. I felt slow.

Weeks 3-4: First surrender.

After 2 weeks of struggle, I went back to VS Code. Productivity returned to normal. I thought "vim really isn't for me." 1 month on VS Code, but I was still curious. I read around, found the concept of "muscle memory" - if you're consistent for 3 weeks, keybindings become reflex.

I tried again. This time, I set a target: 1 month full neovim, no going back to VS Code even if slow.

Weeks 5-8: Plugin setup + LSP.

I set up neovim with plugins: telescope (fuzzy finder), nvim-lspconfig (LSP), treesitter (syntax highlighting), nvim-cmp (autocomplete), lualine (statusline). Lua config. I used lazy.nvim for plugin management.

-- init.lua - simplified version of what I use
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
vim.fn.system({"git", "clone", "https://github.com/folke/lazy.nvim.git", lazypath})
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
-- Fuzzy finder - file navigation
{ "nvim-telescope/telescope.nvim", dependencies = {"nvim-lua/plenary.nvim"} },

-- LSP
{ "neovim/nvim-lspconfig" },

-- Treesitter - better syntax highlighting
{ "nvim-treesitter/nvim-treesitter", build = ":TSUpdate" },

-- Autocomplete
{ "hrsh7th/nvim-cmp", dependencies = {"hrsh7th/cmp-nvim-lsp"} },

-- Statusline
{ "nvim-lualine/lualine.nvim" },
})

-- Basic keybindings
vim.g.mapleader = " "
vim.keymap.set("n", " ff", require("telescope.builtin").find_files)
vim.keymap.set("n", " fg", require("telescope.builtin").live_grep)
vim.keymap.set("n", " fb", require("telescope.builtin").buffers)

Setting up neovim from scratch took 2 days. But now I had: fuzzy file finder (telescope), LSP (jump to definition, references, rename), autocomplete, proper syntax highlighting. Neovim started feeling like a real editor, not a primitive text editor.

Weeks 9-12: Second surrender, then back.

Week 9, I got stuck. My debugging workflow was broken - didn't know how to debug in neovim as easily as VS Code. I quit again, back to VS Code for a week. But I felt "something's missing." VS Code felt heavy, mouse-dependent, lots of clicking.

I went back to neovim. This time, I accepted: neovim won't replace VS Code 100%. I use neovim for 80% of work, VS Code for 20% (complex debugging, remote dev).

---

The "Click" Moment: When I Felt the Difference

Month 4. I was refactoring an 800-line file. In VS Code, I would: scroll to find function, click to position cursor, edit, scroll again, click again. Mouse-heavy.

In neovim, I did: /calculateRefund (search, enter) → ciw (change inside word) → type → n (next search match) → . (repeat last change). All from keyboard. No mouse touch.

When I realized I hadn't lifted my hand from the keyboard for 30 minutes, I felt the difference. Not "faster." But "more flow." The cognitive overhead of "reach mouse, click, back to keyboard" - gone. I focused on code, not the tool.

Modal editing philosophy: normal mode is where you think, insert mode is where you write. VS Code is always insert mode - you're always "ready to type." Vim normal mode - you can navigate, delete, copy, paste without entering insert. You only enter insert when you actually want to write.

The difference from VS Code: in VS Code, navigate = click. In vim, navigate = keybindings. The first needs a mouse, the second doesn't. The first is slow when repeating, the second becomes reflex after muscle memory forms.

---

What Neovim Wins

1. File navigation. Telescope fuzzy finder - ff → type part of filename → enter. Faster than VS Code "Ctrl+P" because telescope is more responsive + preview. fg to grep across project, real-time results.

2. Editing speed (after muscle memory). ciw (change inside word), das (delete around sentence), :%s/old/new/g (replace all), > (indent), . (repeat). Every editing operation = a few keys, no highlighting + clicking menus. After 3 months, this is reflex. Before 3 months, this is slow.

3. Terminal integration. I use tmux + neovim. Split window, terminal on right, code on left, logs at bottom. All keyboard navigation. VS Code has an integrated terminal, but the workflow is still mouse-heavy for pane management.

4. SSH workflow. SSH to server, nvim - config and keybindings same as local. I don't struggle with production debugging anymore. This is a benefit I underestimated initially.

5. Startup speed. Neovim opens a file in 50ms. VS Code in 3-5 seconds (with extensions). For quick edits, a big difference.

6. Config as code. My init.lua is version-controlled (see dotfiles article). Setting up neovim on a new machine = clone repo, install. VS Code settings sync exists, but isn't as flexible - I can't do conditional config (if machine X, use font A; machine Y, use font B).

---

What VS Code Still Wins

Not vim propaganda. VS Code has areas neovim doesn't beat:

1. Debugger UI. DAP (Debug Adapter Protocol) exists in neovim, but setup is fiddly. VS Code debugger = click "play", visual breakpoints, intuitive variable inspector. Neovim debugger (nvim-dap) works, but 5x the setup effort, UX isn't seamless.

2. Remote development. VS Code Remote SSH = 1 click, everything syncs. Neovim on remote = you have to set up neovim on the remote too (or use sshfs, slow). For devs who frequently work remote, VS Code wins clearly.

3. Extension ecosystem. VS Code marketplace has millions of extensions. Neovim plugin ecosystem is growing, but not as deep as VS Code. For devs who need niche extensions (Jupyter notebooks, specific language tools), VS Code is more complete.

4. Team onboarding. Junior dev joins team, immediately uses VS Code. Zero setup. Neovim = requires training, requires time investment. Teams that force neovim = barrier to entry.

5. Pair programming. VS Code Live Share = real-time collaboration, click-to-join. Neovim pair programming (tmate, ssh pair) = more technical setup.

---

Why You Probably Shouldn't Switch

This is the part I want to be honest about. Many vim articles say "vim is an upgrade." I disagree. Vim is a trade, not an upgrade.

If you're happy with VS Code, there's no reason to switch. VS Code is enough for 90% of developers. Autocomplete works, debugger is intuitive, extension ecosystem is rich. You won't be 2x more productive in vim. Maybe 10-20% faster after 6 months investment, but the first 6 months you're 50% slower. The math doesn't always work out.

If you don't SSH often, you don't need it. One of the vim benefits I got: consistent SSH workflow. If you're all local dev, VS Code is enough.

If your team uses VS Code, not worth forcing. Pair programming, code review, onboarding - all easier when everyone uses the same tool. Neovim as an outlier on a team = friction.

If you can't invest 3 months, you won't get returns. 1 week trying neovim = you're slow, no muscle memory, no benefits. 3 months = you start to get flow. 6 months = you're finally productive. If you can't commit 3 months, don't start. Waste of time.

If you're RSI-free, you don't need it. Health reason was valid for me. If your hands are healthy, there's no urgency.

---

What I Learned From the Transition

Muscle memory can't be skipped. I read 10 "vim in 10 minutes" articles. None made me good. What made me good: 3 months of daily use, struggle, repeat. No shortcut.

Plugin ecosystem is power, but also complexity. I once installed 30 plugins. Neovim was heavy, config was complicated, every update broke something. Now I use 8 plugins. Less is more.

Modal editing is a philosophy, not a feature. Not "neovim is faster." Modal editing changes how you think about editing text. You do editing tasks using building blocks (d, c, y, p, .) that compose, not by clicking menus. Once you understand composition, you can express your edits more concisely.

Tools don't make you good. I used to think "if I use vim, I'll be faster." No. You're fast if you understand the problem. Tools only reduce friction, they don't add skill.

Honest trade-off > dogma. I use neovim 80%, VS Code 20%. I'm not too proud to use VS Code when I need the debugger. The "real men use vim" ego = toxic. Real devs use the tool that best solves the problem.

---

An Honest Closing

I'm not writing this to convert you to vim. I'm writing this to be honest about the trade-offs. First 3 months were hell. 6 months to break even. 1 year to be productive. Now I prefer neovim for 80% of cases, but no dogma - VS Code I still use for debugger and remote dev.

The philosophy I learned: a tool is a trade, not an upgrade. Every tool has a cost (learning curve, setup, maintenance) and a benefit (speed, flow, ergonomics). You have to calculate: is the benefit > cost for your use case?

If you're a VS Code user curious about vim: try 1 month. If after 1 month you don't feel "this is worth continuing," stop. No sin. VS Code is enough. If after 1 month you feel "there's something I'm not getting from VS Code," continue 2 more months. 3 months total commitment, then you can judge.

If you're a vim user who wants to condescend to VS Code users: stop. You're not more pro because you use vim. You just have a different trade-off. Real pros use the tool that solves their problem, not the tool that boosts status.

I'm 80% neovim now. But if tomorrow VS Code releases a feature that solves my vim pain points, I'll switch back. Tool loyalty = toxic. Productivity loyalty = healthy.