Gue Pindah dari VS Code ke Neovim (dan Kenapa Lo Mungkin Gak Harus)

Gue pake VS Code dari awal karir. Nyaman. Autocomplete jalan, debugger integrate, extension ecosystem mature, git visual jelas. Temen-temen pake vim, gue ketawain - "kenapa susah-susah, hidup cuma sekali." Gue bilang VS Code cukup, gak butuh modal editor, gak butuh keyboard-only.

2023 gue cobain neovim iseng. Bukan karena butuh. Bukan karena "lebih productive." Curiosity doang. 3 bulan pertama: produktivitas turun 50%. Gue nyerah 2 kali. Sekarang gue 80% neovim, 20% VS Code (debugger, remote dev, pair programming).

Ini bukan artikel "vim is superior." Ini honest reflection - kenapa gue tetep neovim padahal 3 bulan pertama neraka, apa yang neovim menang, apa yang VS Code masih menang, dan kenapa lo mungkin gak harus pindah.

---

Kenapa Gue Coba

Bukan hype. 3 alasan yang jujur:

1. Gue perhatiin senior dev yang gue respect. Mereka pake vim. Bukan semua, tapi yang paling cepet nge-code yang gue kenal, pake vim. Gue pikir: "ada yang mereka tau yang gue gak tau?" Ternyata iya - muscle memory. Mereka gak mikir "cara navigasi", mereka ngelakuin navigasi secara refleks. Beda dengan gue yang masih mikir "mana shortcut buat jump to function."

2. SSH workflow. Gue sering SSH ke server. vim default di server. Tiap debugging production, gue struggle dengan vim basic. Gue pikir: "kalau gue jago vim, debugging server gak ribet."

3. RSI (repetitive strain injury). Gue mulai ngerasa pergelangan tangan sakit. Mouse pakai terus, reach ke trackpad terus. Gue baca keyboard-centric editor bisa ngurangin strain. Curiosity + health reason = cukup reason buat coba.

Alasan yang gak jadi pertimbangan:
• "Vim bikin lo kelihatan pro" - ego, skip
• "VS Code itu bloated" - betul tapi itu side effect, bukan reason
• "Modal editing lebih cepat" - belum terbukti buat gue saat itu

---

3 Bulan Pertama: Neraka yang Bikin Gue Nyerah 2 Kali

Gue gak mau sugar-coat. Transisi itu sakit. Productivity turun. Ego turun. Gue yang merasa jago nge-code, jadi kelihatan pemula.

Minggu 1-2: Vim tutor + basic keybindings.

Gue jalanin vimtutor 3x. Belajar hjkl, w, b, e, i, a, o, d, y, p. Modal editing concept: normal mode, insert mode, visual mode. Gue yang terbiasa "klik, ketik, klik" - terjebak. Tiap mau edit, gue musti mikir "masuk insert mode dulu, ketik, balik normal mode." Cognitive load tinggi.

" Yang gue pake di minggu 1:
i " insert mode (ketik)
Esc " balik normal mode
:wq " save & quit
dd " delete line
yy " yank line
p " paste
/keyword " search
n / N " next / previous search

8 keybindings. Tapi tiap mau nulis, gue musti ngerjain 3 step (masuk insert, ketik, balik normal). VS Code: tinggal klik dan ketik. Gue ngerasa lambat.

Minggu 3-4: Nyerah pertama.

Setelah 2 minggu struggle, gue balik VS Code. Productivity balik normal. Gue pikir "vim emang gak buat gue." 1 bulan jalan VS Code, tapi gue masih penasaran. Gue baca-baca, nemu konsep "muscle memory" - kalo lo konsisten 3 minggu, keybindings jadi reflex.

Gue coba lagi. Kali ini, gue set target: 1 bulan full neovim, gak boleh balik VS Code walau lambat.

Minggu 5-8: Plugin setup + LSP.

Gue setup neovim with plugins: telescope (fuzzy finder), nvim-lspconfig (LSP), treesitter (syntax highlighting), nvim-cmp (autocomplete), lualine (statusline). Lua config. Gue pake lazy.nvim buat plugin management.

-- init.lua - simplified version of what gue pake
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)

Setup neovim dari nol butuh 2 hari. Tapi sekarang gue punya: fuzzy file finder (telescope), LSP (jump to definition, references, rename), autocomplete, syntax highlighting proper. Neovim mulai terasa kayak editor beneran, bukan text editor primitive.

Minggu 9-12: Nyerah kedua, lalu balik.

Minggu 9, gue stuck. Debugging workflow gue broken - gak tau cara debug neovim se-praktis VS Code. Gue nyerah lagi, balik VS Code 1 minggu. Tapi gue ngerasa "kayak ada yang kurang." VS Code ngerasa berat, mouse-dependent, banyak click.

Gue balik neovim. Kali ini, gue accept: neovim gak akan ganti VS Code 100%. Gue pake neovim buat 80% pekerjaan, VS Code buat 20% (debugging complex, remote dev).

---

Momen "Klik": Saat Gue Ngerasa Bedanya

Bulan ke-4. Gue lagi refactor file 800 baris. Di VS Code, gue akan: scroll cari function, click untuk position cursor, edit, scroll lagi, click lagi. Mouse-heavy.

Di neovim, gue: /calculateRefund (search, enter) → ciw (change inside word) → ketik → n (next search match) → . (repeat last change). Semua dari keyboard. Gak sentuh mouse.

Saat gue sadar gak angkat tangan dari keyboard selama 30 menit, gue ngerasa bedanya. Bukan "lebih cepet." Tapi "lebih flow." Cognitive overhead dari "reach mouse, click, balik keyboard" - ilang. Gue fokus ke code, bukan ke tool.

Filosofi modal editing: normal mode is where you think, insert mode is where you write. VS Code selalu insert mode - lo selalu "ready to type." Vim normal mode - lo bisa navigate, delete, copy, paste tanpa masuk insert. Lo baru masuk insert pas emang mau nulis.

Bedanya vs VS Code: di VS Code, navigate = click. Di vim, navigate = keybindings. Yang pertama butuh mouse, yang kedua gak. Yang pertama slow pas ngulang, yang kedua jadi reflex setelah muscle memory kebentuk.

---

Apa yang Neovim Menang

1. File navigation. Telescope fuzzy finder - ff → ketik sebagian nama file → enter. Lebih cepet dari VS Code "Ctrl+P" karena telescope lebih responsive + preview. fg buat grep across project, hasil real-time.

2. Editing speed (after muscle memory). ciw (change inside word), das (delete around sentence), :%s/old/new/g (replace all), > (indent), . (repeat). Setiap operasi editing = beberapa key, gak harus highlight + click menu. After 3 bulan, ini reflex. Sebelum 3 bulan, ini slow.

3. Terminal integration. Gue pake tmux + neovim. Split window, terminal di kanan, code di kiri, log di bawah. Semua keyboard navigation. VS Code punya integrated terminal, tapi workflow-nya masih mouse-heavy untuk pane management.

4. SSH workflow. SSH ke server, nvim - config dan keybindings sama kayak local. Gue gak struggle lagi debugging production. Ini benefit yang gue underestimate awalnya.

5. Startup speed. Neovim buka file 50ms. VS Code 3-5 detik (dengan extension). Untuk quick edit, beda banget.

6. Config as code. Init.lua gue version-controlled (lihat artikel dotfiles). Setup neovim di machine baru = clone repo, install. VS Code settings sync ada, tapi gak fleksibel - gue gak bisa conditional config (kalau machine X, pake font A; machine Y, pake font B).

---

Apa yang VS Code Masih Menang

Bukan propaganda vim. VS Code punya area yang neovim gak ngalahin:

1. Debugger UI. DAP (Debug Adapter Protocol) di neovim ada, tapi setup-nya ribet. VS Code debugger = click "play", breakpoint visual, variable inspector intuitive. Neovim debugger (nvim-dap) bisa, tapi 5x effort setup, UX gak seamless.

2. Remote development. VS Code Remote SSH = 1 click, semua sync. Neovim di remote = harus setup neovim di remote juga (atau pake sshfs, slow). Untuk dev yang sering remote, VS Code menang telak.

3. Extension ecosystem. VS Code marketplace jutaan extension. Neovim plugin ecosystem berkembang, tapi gak sedalam VS Code. Buat dev yang butuh extension niche (Jupyter notebook, specific language tools), VS Code lebih lengkap.

4. Onboarding tim. Junior dev masuk tim, langsung pake VS Code. Zero setup. Neovim = butuh training, butuh time investment. Tim yang 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.

---

Kenapa Lo Mungkin Gak Harus Pindah

Ini bagian yang gue mau honest. Banyak artikel vim yang bilang "vim itu upgrade." Gue gak setuju. Vim itu trade, bukan upgrade.

Kalau lo happy with VS Code, gak ada alasan pindah. VS Code udah cukup buat 90% developer. Autocomplete jalan, debugger intuitive, extension ecosystem rich. Lo gak akan 2x lebih produktif di vim. Mungkin 10-20% lebih cepet after 6 bulan investment, tapi 6 bulan pertama lo 50% lebih lambat. Math-nya gak selalu worth.

Kalau lo gak sering SSH, gak butuh. Salah satu benefit vim yang gue dapet: SSH workflow consistent. Kalau lo semua dev local, VS Code cukup.

Kalau tim lo pake VS Code, gak worth force. Pair programming, code review, onboarding - semua lebih gampang kalau semua pake tool sama. Neovim sebagai outlier di tim = friction.

Kalau lo gak invest 3 bulan, gak akan dapet return. 1 minggu cobain neovim = lo lambat, gak dapet muscle memory, gak ada benefit. 3 bulan = baru mulai dapet flow. 6 bulan = baru productive. Kalau lo gak komit 3 bulan, jangan mulai. Waste waktu.

Kalau lo RSI-free, gak butuh. Health reason valid buat gue. Kalau tangan lo sehat, gak ada urgency.

---

Yang Gue Pelajarin Dari Transisi

Muscle memory gak bisa di-skip. Gue baca 10 artikel "vim dalam 10 menit." Gak ada yang bikin gue jago. Yang bikin jago: 3 bulan pakai sehari-hari, struggle, repeat. Gak ada shortcut.

Plugin ecosystem itu power, tapi juga complexity. Gue pernah install 30 plugin. Neovim berat, config ribet, tiap update ada yang break. Sekarang gue pake 8 plugin. Less is more.

Modal editing is a philosophy, not a feature. Bukan "neovim lebih cepet." Modal editing nge-ubah cara lo mikir tentang editing text. Lo ngerjain task editing pake building blocks (d, c, y, p, .) yang compose-able, bukan click menu. Setelah lo paham composition, lo bisa express edit lo lebih concise.

Tool gak bikin lo jago. Gue pernah pikir "kalau pake vim, gue bakal lebih cepet." Enggak. Lo cepet kalau lo paham problem-nya. Tool cuma reduce friction, bukan nambah skill.

Honest trade-off > dogma. Gue pake neovim 80%, VS Code 20%. Gue gak malas pake VS Code pas butuh debugger. Ego "real men use vim" = toxic. Real dev pake tool yang paling solve problem.

---

Penutup yang Jujur

Gue gak nulis ini buat convert lo ke vim. Gue nulis ini buat jujur soal trade-off. 3 bulan pertama neraka. 6 bulan baru break-even. 1 tahun baru productive. Sekarang gue prefer neovim buat 80% case, tapi gak dogma - VS Code masih gue pake buat debugger dan remote dev.

Filosofi yang gue pelajarin: tool itu trade, bukan upgrade. Setiap tool punya cost (learning curve, setup, maintenance) dan benefit (speed, flow, ergonomics). Lo musti ngitung: apakah benefit > cost buat use case lo?

Kalau lo VS Code user yang penasaran vim: coba 1 bulan. Kalau setelah 1 bulan lo gak ngerasa "ini worth lanjut," stop. Gak dosa. VS Code cukup. Kalau setelah 1 bulan lo ngerasa "ada something yang gue gak dapet dari VS Code," lanjut 2 bulan lagi. 3 bulan total commitment, baru lo bisa judge.

Kalau lo vim user yang mau condescend ke VS Code user: stop. Lo gak lebih pro karena pake vim. Lo cuma beda trade-off. Real pro pake tool yang solve problemnya, bukan tool yang bikin status.

Gue 80% neovim sekarang. Tapi kalau besok VS Code rilis feature yang solve vim pain point gue, gue bakal balik. Loyalty ke tool = toxic. Loyalty ke productivity = sehat.