Vim After Ten Years: The Setup I Still Can't Quit

I've been using vim for over a decade. Not because I'm a purist, not because I hate GUIs, and definitely not because I enjoy explaining hjkl to people. I use it because once the muscle memory clicks, everything else feels like typing with mittens.

Here's the thing nobody tells you about vim: the first six months are miserable. You'll hit esc in every other editor. You'll type :wq into Slack. You'll curse the day you ever heard of modal editing. And then one day you realize you just deleted three words, changed a function name across six files, and reformatted a paragraph without leaving the keyboard. That's when it hooks you.

The .vimrc That Actually Works

Here's my .vimrc after ten years of trimming. I've deleted more than I've added. That's the real secret.

" Core settings
set nocompatible
set number
set relativenumber
set tabstop=4
set shiftwidth=4
set expandtab
set autoindent
set smartindent
set incsearch
set hlsearch
set ignorecase
set smartcase
set wildmenu
set laststatus=2
set showmatch
set cursorline
set scrolloff=8
set signcolumn=yes
set encoding=utf-8
set mouse=a
set updatetime=100
set timeoutlen=500
set splitbelow
set splitright

" Plugin manager ( vim-plug )
call plug#begin('~/.vim/plugged')
Plug 'tpope/vim-surround'
Plug 'tpope/vim-commentary'
Plug 'tpope/vim-fugitive'
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
Plug 'neoclide/coc.nvim', { 'branch': 'release' }
Plug 'preservim/nerdtree'
Plug 'morhetz/gruvbox'
call plug#end()

" Theme
colorscheme gruvbox
set background=dark

" Key mappings
let mapleader = ' '
nnoremap <leader>w :w<CR>
nnoremap <leader>q :q<CR>
nnoremap <leader>e :NERDTreeToggle<CR>
nnoremap <C-p> :Files<CR>
nnoremap <leader>rg :Rg<CR>
nnoremap <leader>b :Buffers<CR>

That's it. Fourteen plugins, every one earning its spot. If a plugin doesn't save me time every single day, it's gone.

The Motions That Changed How I Think About Text

Most people learn vim motions one at a time, like collecting baseball cards. That's backwards. Learn the grammar first.

[count][operator][motion]

Operators are d ( delete ), c ( change ), y ( yank ), > ( indent ). Motions are w ( word ), b ( back ), j/k ( lines ), i/a ( inside/around ). Combine them and you get a language.

dw       " delete word
ci"      " change inside quotes
yi)      " yank inside parentheses
d3j      " delete 3 lines down
>aip     " indent around inner paragraph
ct,      " change till comma

The real power move: ci" changes text inside quotes regardless of how long it is. dit deletes the inner tag in HTML. These compound motions are where vim becomes genuinely faster than anything else.

Splits, Tabs, and Buffers: The Navigation Setup

This is where most people get confused. Buffers, tabs, and splits are not the same thing, and treating them like they are makes vim worse.

" Buffer navigation ( what I use 99% of the time )
nnoremap <leader>bn :bnext<CR>
nnoremap <leader>bp :bprevious<CR>
nnoremap <leader>bd :bdelete<CR>
nnoremap <leader>bb :Buffers<CR>

" Splits
nnoremap <C-h> <C-w>h
nnoremap <C-j> <C-w>j
nnoremap <C-k> <C-w>k
nnoremap <C-l> <C-w>l

" Resize splits
nnoremap <C-Up> :resize +2<CR>
nnoremap <C-Down> :resize -2<CR>
nnoremap <C-Left> :vertical resize +2<CR>
nnoremap <C-Right> :vertical resize -2<CR>

I use buffers for everything. Tabs are basically browser tabs for vim — useful sometimes, abused often. Splits are for when I genuinely need two files visible at once. Not for hoarding open files like some kind of digital dragon.

FZF and Ripgrep: Finding Things Fast

If you're still using :find or tab-completing file paths, stop. fzf plus ripgrep is the fastest way to navigate a codebase, period.

" Install ripgrep first ( it replaces grep everywhere )
" Ubuntu/Debian: sudo apt install ripgrep
" macOS: brew install ripgrep

" fzf.vim gives you these commands:
" :Files     — fuzzy find files
" :Rg        — ripgrep across project
" :Buffers   — switch between open buffers
" :Lines     — search within open buffers

" My most-used mapping
nnnoremap <C-p> :Files<CR>
nnoremap <leader>rg :Rg<CR>

:Rg with ripgrep is faster than any IDE search I've ever used. Partly because ripgrep is absurdly fast, partly because the fzf preview shows you context immediately. No clicking, no loading panels, no waiting.

Neovim vs Vim: My Take

I switched to neovim two years ago. The Lua config is cleaner, LSP support via coc.nvim or native LSP is better, and the async execution doesn't block the UI. But here's the honest truth: for the first five years of my vim life, plain vim was fine.

Switch when you feel the friction, not because a blog post told you to. ( Even this one. )

-- Neovim init.lua ( the modern way )
-- Replace .vimrc with ~/.config/nvim/init.lua

local set = vim.opt
set.number = true
set.relativenumber = true
set.tabstop = 4
set.shiftwidth = 4
set.expandtab = true
set.scrolloff = 8
set.signcolumn = 'yes'

-- Plugin manager: lazy.nvim
local lazypath = vim.fn.stdpath('data') .. '/lazy/lazy.nvim'
vim.opt.rtp:prepend(lazypath)

require('lazy').setup({
    'tpope/vim-surround',
    'tpope/vim-commentary',
    'morhetz/gruvbox',
    { 'neoclide/coc.nvim', branch = 'release' },
})

Same plugins, same philosophy. Lua is nicer to write than VimScript, but the end result is the same: a fast editor that stays out of your way.

The Five Motions I Use Most

In no particular order, these are the ones that save me the most time daily:

ci"     change inside quotes — refactor strings
dit     delete inside tag — edit HTML
vipJ    select paragraph, join lines — reformat text
ddp     swap current line with line below
*       search for word under cursor

Learn those five. Use them until they're automatic. Then learn five more. That's how vim mastery actually works — not by memorizing a wall of shortcuts, but by adding one motion at a time until your fingers know more than your brain does.

My .vimrc and neovim config are at github.com/davideandreazzini/dotfiles. Steal whatever's useful. :)