Neovim — Deep Study: Modern Vim with Lua & Plugins

What is Neovim? Modes Essential Keys Configuration Plugin Manager Popular Plugins LSP Stack Telescope Treesitter Git Plugins UI & UX Distributions Best Practices

What is Neovim?

Neovim is a hyperextensible Vim-based text editor designed for the modern developer. It keeps Vim's modal editing model and keybindings but adds a first-class Lua scripting API, built-in LSP client, async job control, and a rich plugin ecosystem. It runs in the terminal and is highly configurable.

Core Philosophy: Everything is text-first, keyboard-driven, and infinitely customizable. Once muscle memory is built, Neovim makes editing dramatically faster than any mouse-based editor.

⌨️

Modal Editing

Different modes for navigation, editing, and commands — keeps hands on the keyboard

🌙

Lua Config

Full Lua scripting API — configs are real programs, not just config files

🔌

LSP Built-in

Native Language Server Protocol client — go-to-def, hover, diagnostics, formatting

🌳

Treesitter

Incremental syntax trees — precise highlighting, text objects, and folding

⚡

Performance

Async by default — UI never blocks, large files open instantly

🆓

Free & Open

Apache 2.0 / Vim license. Zero cost, fully open source, runs anywhere

Vim vs Neovim

Feature	Vim	Neovim
Config language	VimScript	Lua (+ VimScript)
LSP support	Via plugin (CoC)	Built-in LSP client
Async execution	Limited	Full async via libuv
Treesitter	No	Built-in
Plugin API	VimScript API	Lua API + VimScript compat
Floating windows	No	Yes (popups, UI plugins)
Terminal emulator	Basic	Full terminal mode
Remote plugins	No	Yes (RPC msgpack)
Health checks	No	:checkhealth built-in

Modes — The Foundation

Understanding modes is the single most important concept in Neovim. Every key press does something different depending on which mode you're in.

Normal Mode

Default mode

Navigate, copy, delete, and run commands. This is where you spend most time.

Enter from Insert: Esc or Ctrl+[
Every key is a command — no text insertion
Hjkl for movement, operators like d, c, y

Insert Mode

Type text

Where you actually type text. Enter with i, a, o, I, A, O.

i — insert before cursor
a — insert after cursor
o / O — new line below/above
I / A — start/end of line

Visual Mode

Select text

Select text for operations. Three variants:

v — character visual
V — line visual
Ctrl+v — block visual (column select)
Then apply operators: d, y, c, >, <, =

Command Mode

Ex commands

Run commands, search, substitute. Enter with :.

:w — save
:q — quit
:wq — save and quit
:s/old/new/g — substitute
/pattern — search

Terminal Mode

Embedded terminal

Run a real terminal inside Neovim. Enter with :term, exit with Ctrl+\ Ctrl+n.

Full shell inside a buffer
Switch to Normal with Ctrl+\ Ctrl+n
Popular with toggleterm.nvim

Replace Mode

Overwrite text

Overwrite characters in place. Enter with R from Normal mode.

r — replace single character
R — enter replace mode (type over)

Essential Keybindings

These are the most important keybindings to learn. Master these before adding plugins. All keybindings below work in NORMAL mode unless noted.

Motion & Navigation

Key	Action	Notes
`h` `j` `k` `l`	Left / Down / Up / Right	Never use arrow keys
`w` / `b`	Next / prev word start	`W`/`B` = WORD (whitespace-delimited)
`e` / `ge`	Next / prev word end
`0` / `^` / `$`	Line start / first non-blank / line end
`gg` / `G`	Top / bottom of file	`42G` = jump to line 42
`Ctrl+d` / `Ctrl+u`	Scroll half page down / up	Most common scrolling
`Ctrl+f` / `Ctrl+b`	Full page down / up
`%`	Jump to matching bracket	Works on (, [, {
`f{char}` / `F{char}`	Find char forward / backward on line	`;` repeat, `,` reverse
`t{char}` / `T{char}`	Till char forward / backward	Cursor stops before char
`*` / `#`	Search word under cursor fwd / back	Very fast for symbol search
`zz` / `zt` / `zb`	Center / top / bottom cursor line
`` / `''`	Jump back to last position	`Ctrl+o` / `Ctrl+i` = jump list

Editing Operators & Text Objects

Operator + Motion/Text-Object: Neovim editing uses a grammar: [count] operator [text-object/motion]. E.g. d2w = delete 2 words, ci" = change inside quotes.

Key	Action	Examples
`d`	Delete (cut)	`dw` word, `dd` line, `D` to end
`c`	Change (delete + insert)	`cw` word, `cc` line, `C` to end
`y`	Yank (copy)	`yw` word, `yy` line, `y$` to end
`p` / `P`	Paste after / before cursor
`u` / `Ctrl+r`	Undo / Redo	Neovim has persistent undo
`.`	Repeat last change	One of the most powerful keys
`x` / `X`	Delete char under / before cursor
`r{char}`	Replace char under cursor
`~`	Toggle case	`gu{motion}` lowercase, `gU` uppercase
`>` / `<`	Indent / de-indent	`>>` line, `=%` auto-indent block
`J`	Join lines

Text Objects (combine with d, c, y, v)

Object	Meaning	i = inner, a = around
`iw` / `aw`	Word	iw = word only, aw = word + space
`i"` / `a"`	Double quoted string	ci" = change inside quotes
`i'` / `a'`	Single quoted string
`i(` / `a(`	Parentheses	Also `ib` / `ab`
`i{` / `a{`	Curly braces	Also `iB` / `aB`
`i[` / `a[`	Square brackets
`it` / `at`	HTML/XML tag	cit = change inside tag
`ip` / `ap`	Paragraph
`is` / `as`	Sentence

Windows, Tabs & Buffers

Key	Action
`:sp` / `:vsp`	Horizontal / vertical split
`Ctrl+w h/j/k/l`	Move between splits
`Ctrl+w =`	Equalize split sizes
`Ctrl+w q`	Close split
`:tabnew` / `gt` / `gT`	New tab / next tab / prev tab
`:bn` / `:bp`	Next / prev buffer
`:bd`	Delete (close) buffer
`:ls`	List all open buffers

Configuration

Neovim looks for config in ~/.config/nvim/. The entry point is init.lua. All configuration is written in Lua.

Recommended Directory Structure

~/.config/nvim/ ├── init.lua -- entry point, loads all modules └── lua/ └── config/ │ ├── lazy.lua -- plugin manager bootstrap │ ├── options.lua -- vim.opt settings │ ├── keymaps.lua -- custom keybindings │ └── autocmds.lua -- autocommands └── plugins/ ├── lsp.lua -- Mason + lspconfig ├── telescope.lua -- fuzzy finder ├── treesitter.lua -- syntax highlighting ├── completion.lua -- nvim-cmp └── ui.lua -- colorscheme, statusline, etc.

Core Options (options.lua)

local opt = vim.opt

-- Line numbers
opt.number = true           -- absolute line number
opt.relativenumber = true   -- relative numbers (great for jumps)

-- Indentation
opt.tabstop = 2
opt.shiftwidth = 2
opt.expandtab = true        -- spaces instead of tabs
opt.smartindent = true

-- Search
opt.ignorecase = true
opt.smartcase = true        -- case-sensitive if uppercase present
opt.hlsearch = false        -- no persistent highlight after search

-- UI
opt.termguicolors = true    -- 24-bit colors
opt.signcolumn = "yes"       -- always show sign column (git, LSP)
opt.cursorline = true       -- highlight current line
opt.scrolloff = 8           -- keep 8 lines visible around cursor
opt.wrap = false            -- no line wrapping
opt.colorcolumn = "80"      -- ruler at 80 chars

-- Files
opt.undofile = true         -- persistent undo across sessions
opt.updatetime = 250        -- faster CursorHold (good for LSP)
opt.clipboard = "unnamedplus" -- sync with system clipboard

-- Splits
opt.splitbelow = true       -- horizontal splits go below
opt.splitright = true       -- vertical splits go right

Keymaps in Lua (keymaps.lua)

local map = vim.keymap.set

-- Leader key (space is the most common choice)
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- Better escape
map("i", "jk", "<Esc>", { desc = "Exit insert mode" })

-- Move between windows with Ctrl+hjkl
map("n", "<C-h>", "<C-w>h", { desc = "Move left" })
map("n", "<C-j>", "<C-w>j", { desc = "Move down" })
map("n", "<C-k>", "<C-w>k", { desc = "Move up" })
map("n", "<C-l>", "<C-w>l", { desc = "Move right" })

-- Buffer navigation
map("n", "<S-h>", ":bprevious<CR>", { desc = "Prev buffer" })
map("n", "<S-l>", ":bnext<CR>",     { desc = "Next buffer" })

-- Keep selection after indent
map("v", "<", "<gv")
map("v", ">", ">gv")

-- Move selected lines up/down
map("v", "J", ":m '>+1<CR>gv=gv")
map("v", "K", ":m '<-2<CR>gv=gv")

-- Clear search highlight
map("n", "<Esc>", ":nohlsearch<CR>")

-- Save with leader+w
map("n", "<leader>w", ":w<CR>", { desc = "Save file" })
map("n", "<leader>q", ":q<CR>", { desc = "Quit" })

Plugin Manager — lazy.nvim

lazy.nvim is the current standard plugin manager for Neovim. It features lazy-loading by default (plugins only load when needed), a beautiful UI, lockfile for reproducibility, and fast startup times.

Bootstrap lazy.nvim

-- ~/.config/nvim/lua/config/lazy.lua
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  spec = {
    { import = "plugins" },  -- auto-imports lua/plugins/*.lua
  },
  defaults = { lazy = true },   -- lazy-load everything by default
  install = { colorscheme = { "catppuccin" } },
  checker = { enabled = true },  -- auto-check for plugin updates
  performance = {
    rtp = {
      disabled_plugins = {        -- disable unused built-in plugins
        "gzip", "tarPlugin", "tohtml", "tutor", "zipPlugin",
      },
    },
  },
})

Plugin Spec Examples

-- lua/plugins/example.lua
return {
  -- Simple plugin (no config needed)
  { "nvim-lua/plenary.nvim", lazy = true },

  -- Plugin with options
  {
    "nvim-telescope/telescope.nvim",
    cmd = "Telescope",             -- lazy: load on command
    keys = { { "<leader>ff", ... } }, -- lazy: load on keymap
    dependencies = { "nvim-lua/plenary.nvim" },
    opts = {                       -- passed to plugin.setup()
      defaults = { prompt_prefix = "🔍 " }
    },
  },

  -- Plugin with full config function
  {
    "hrsh7th/nvim-cmp",
    event = "InsertEnter",         -- lazy: load when entering insert
    config = function()
      local cmp = require("cmp")
      cmp.setup({ --[[ ... ]] })
    end,
  },
}

lazy.nvim Key Commands

Command	Action
`:Lazy`	Open lazy UI (install/update/sync)
`:Lazy sync`	Update all plugins to latest
`:Lazy update`	Update plugins (keeping lazy-lock.json)
`:Lazy clean`	Remove unused plugins
`:Lazy profile`	Show plugin load times
`:Lazy log`	Show recent plugin changes

Popular Plugins

🔌 LSP Stack (Code Intelligence)

The LSP stack gives you IDE features: go-to-definition, hover docs, diagnostics, rename, code actions. Three components work together:

mason.nvim -- installs language servers, linters, formatters │ └─► mason-lspconfig.nvim -- bridges mason ↔ lspconfig │ └─► nvim-lspconfig -- configures each language server │ └─► Neovim LSP Client -- built-in, receives LSP events

mason.nvim

williamboman/mason.nvim

Package manager for LSP servers, DAP adapters, linters, and formatters. Install with :Mason.

Keys: :Mason, :MasonInstall typescript-language-server

nvim-lspconfig

neovim/nvim-lspconfig

Community configs for 100+ language servers. Handles server startup, capabilities, and default keymaps.

Keys: gd goto-def, K hover, <leader>rn rename

conform.nvim

stevearc/conform.nvim

Fast, async code formatter. Supports prettier, black, stylua, gofmt, and 50+ more. Replaces null-ls for formatting.

Keys: <leader>cf format file, or format on save

nvim-lint

mfussenegger/nvim-lint

Async linting via external linters (eslint, pylint, shellcheck). Pairs with conform.nvim — one for format, one for lint.

Runs on BufWritePost / TextChanged events

-- lua/plugins/lsp.lua — minimal LSP setup
return {
  {
    "neovim/nvim-lspconfig",
    event = { "BufReadPre", "BufNewFile" },
    dependencies = { "williamboman/mason-lspconfig.nvim" },
    config = function()
      local lspconfig = require("lspconfig")
      local capabilities = require("cmp_nvim_lsp").default_capabilities()

      -- TypeScript
      lspconfig.ts_ls.setup({ capabilities = capabilities })
      -- Python
      lspconfig.pyright.setup({ capabilities = capabilities })
      -- Lua (for Neovim config itself)
      lspconfig.lua_ls.setup({ capabilities = capabilities })

      -- LSP keymaps — set on LspAttach
      vim.api.nvim_create_autocmd("LspAttach", {
        callback = function(ev)
          local map = vim.keymap.set
          local buf = ev.buf
          map("n", "gd",          vim.lsp.buf.definition,     { buffer = buf, desc = "Goto definition" })
          map("n", "gD",          vim.lsp.buf.declaration,    { buffer = buf })
          map("n", "K",           vim.lsp.buf.hover,          { buffer = buf, desc = "Hover docs" })
          map("n", "gr",          vim.lsp.buf.references,     { buffer = buf, desc = "References" })
          map("n", "<leader>rn", vim.lsp.buf.rename,         { buffer = buf, desc = "Rename" })
          map("n", "<leader>ca", vim.lsp.buf.code_action,    { buffer = buf, desc = "Code action" })
          map("n", "[d",          vim.diagnostic.goto_prev,   { buffer = buf })
          map("n", "]d",          vim.diagnostic.goto_next,   { buffer = buf })
        end,
      })
    end,
  },
}

✅ Autocompletion

nvim-cmp

hrsh7th/nvim-cmp

The standard completion engine. Aggregates sources: LSP, snippets, buffer words, file paths. Highly configurable.

Keys: Ctrl+n/p navigate, Ctrl+y confirm, Ctrl+e abort

blink.cmp

Saghen/blink.cmp

New faster completion engine written in Rust. Up to 10x faster than nvim-cmp. Growing rapidly in popularity.

Drop-in replacement for nvim-cmp with better performance

LuaSnip

L3MON4D3/LuaSnip

Powerful snippet engine. Works with nvim-cmp. Supports VSCode snippets, LuaSnip format, and dynamic snippets.

Keys: Tab expand/jump, S-Tab jump back

friendly-snippets

rafamadriz/friendly-snippets

Community snippet collection for 50+ languages. Load with LuaSnip's VSCode loader — instant snippet library.

require("luasnip.loaders.from_vscode").lazy_load()

🔭 Telescope — Fuzzy Finder

Telescope is the most popular Neovim plugin. A fuzzy finder over lists — files, buffers, git commits, LSP symbols, keymaps, anything.

telescope.nvim

nvim-telescope/telescope.nvim

Highly extensible fuzzy finder. 100+ built-in pickers. Built on top of plenary.nvim.

<leader>ff files, <leader>fg grep, <leader>fb buffers, <leader>fh help tags

telescope-fzf-native

nvim-telescope/telescope-fzf-native.nvim

C-based fzf sorter for Telescope. 10-50x faster than the default Lua sorter. Always install this.

Requires: gcc or cmake to build

-- Essential Telescope keymaps
local builtin = require("telescope.builtin")
map("n", "<leader>ff", builtin.find_files,               { desc = "Find files" })
map("n", "<leader>fg", builtin.live_grep,                { desc = "Live grep" })
map("n", "<leader>fb", builtin.buffers,                  { desc = "Buffers" })
map("n", "<leader>fh", builtin.help_tags,               { desc = "Help" })
map("n", "<leader>fs", builtin.lsp_document_symbols,    { desc = "Document symbols" })
map("n", "<leader>fr", builtin.oldfiles,                 { desc = "Recent files" })
map("n", "<leader>fc", builtin.commands,                 { desc = "Commands" })
map("n", "<leader>/",  builtin.current_buffer_fuzzy_find, { desc = "Search buffer" })

🌳 Treesitter — Syntax Intelligence

nvim-treesitter

nvim-treesitter/nvim-treesitter

Incremental parsing for 100+ languages. Provides precise syntax highlighting, indentation, and text objects. Far superior to regex-based highlighting.

Commands: :TSInstall python, :TSUpdate

nvim-treesitter-textobjects

nvim-treesitter/nvim-treesitter-textobjects

Adds syntax-aware text objects: if (inside function), ac (around class), ]m (next method).

vaf select function, dac delete class

nvim-treesitter-context

nvim-treesitter/nvim-treesitter-context

Shows the current function/class context at the top of the screen as you scroll through long files.

Always-on — no keymap needed

📁 File Tree Explorer

neo-tree.nvim

nvim-neo-tree/neo-tree.nvim

Modern file tree with buffers, git status, filesystem. Floating or sidebar modes. Most popular choice today.

<leader>e toggle tree, a add, d delete, r rename

nvim-tree.lua

nvim-tree/nvim-tree.lua

Fast, icon-rich file tree. Alternative to neo-tree. Simpler but slightly less feature-rich. Good choice too.

<leader>e toggle, g? help in tree

oil.nvim

stevearc/oil.nvim

Edit filesystem like a buffer. Navigate directories as text files, create/rename/delete by editing buffer content.

- open parent dir, :w save changes to disk

🔀 Git Integration

gitsigns.nvim

lewis6991/gitsigns.nvim

Shows git hunk indicators in the sign column (+/-/~). Inline blame, stage hunks, preview diffs — all inside Neovim.

]c next hunk, [c prev hunk, <leader>hs stage hunk, <leader>gb blame line

vim-fugitive

tpope/vim-fugitive

The classic Git integration. Run any git command with :G. Interactive staging with :Git, diff with :Gdiff.

:G status, :Gcommit, :Gpush, :Gdiff

lazygit.nvim

kdheepak/lazygit.nvim

Opens lazygit in a floating terminal inside Neovim. Best of both worlds — full lazygit TUI without leaving the editor.

<leader>gg open lazygit

diffview.nvim

sindrets/diffview.nvim

Beautiful side-by-side diffs and git history browser. Essential for code reviews inside Neovim.

:DiffviewOpen, :DiffviewFileHistory

🎨 UI & UX Enhancement

lualine.nvim

nvim-lualine/lualine.nvim

Fast, configurable statusline in Lua. Shows mode, file, git branch, LSP diagnostics, location. Many built-in themes.

No keymaps — always-on statusline at bottom

bufferline.nvim

akinsho/bufferline.nvim

Visual tab/buffer line at the top. Shows open buffers as tabs with icons and close buttons. Essential for multi-file work.

<S-h>/<S-l> prev/next, <leader>bd close buffer

which-key.nvim

folke/which-key.nvim

Popup showing available keymaps after a prefix key (e.g., press <leader> and wait). Discovers forgotten keymaps instantly.

Press <leader> and wait ~500ms to see popup

noice.nvim

folke/noice.nvim

Completely replaces the cmdline, popup messages, and notifications with modern floating UI. Makes Neovim look like VS Code.

<leader>sn notifications, :Noice history

alpha-nvim

goolord/alpha-nvim

Greeter/dashboard shown when Neovim opens with no file. Shows recent files, quick actions, and ASCII art.

Shows on startup. Configure buttons for your most common actions.

indent-blankline.nvim

lukas-reineke/indent-blankline.nvim

Shows indent guides (vertical lines) and highlights the current indent scope. Makes deeply nested code readable.

Always-on. Toggle with :IBLToggle

catppuccin

catppuccin/nvim

Most popular Neovim colorscheme. 4 flavors: latte, frappé, macchiato, mocha. Integrates with all major plugins.

:colorscheme catppuccin-mocha

tokyonight.nvim

folke/tokyonight.nvim

Classic dark blue theme by folke. 4 styles: night, storm, moon, day. Excellent plugin integration. Very popular.

:colorscheme tokyonight-night

⚡ Coding Helpers

nvim-autopairs

windwp/nvim-autopairs

Auto-closes brackets, quotes, and tags. Integrates with nvim-cmp so accepted completions don't double-pair.

Works automatically in Insert mode

Comment.nvim

numToStr/Comment.nvim

Smart commenting with correct comment syntax per language. Treesitter integration for embedded languages.

gcc comment line, gc comment motion, gcA end-of-line comment

nvim-surround

kylechui/nvim-surround

Add, change, delete surrounding characters. The spiritual successor to tpope's vim-surround, written in Lua.

ys{motion}{char} add, cs{old}{new} change, ds{char} delete

flash.nvim

folke/flash.nvim

Enhanced navigation with jump labels. Type a few chars, jump exactly to the match with a label key. Replaces hop/leap.

s flash search, S Treesitter-aware jump

toggleterm.nvim

akinsho/toggleterm.nvim

Persistent toggleable terminal(s). Float, horizontal, vertical, or tab. Send lines from buffer to terminal.

Ctrl+\ toggle terminal, <leader>gg lazygit

trouble.nvim

folke/trouble.nvim

Pretty diagnostics, LSP references, TODOs panel. Aggregates all errors/warnings in a browsable list below the editor.

<leader>xx toggle trouble, <leader>xw workspace diagnostics

todo-comments.nvim

folke/todo-comments.nvim

Highlights TODO, FIXME, HACK, NOTE comments and makes them searchable via Telescope or Trouble.

]t/[t next/prev todo, <leader>st search todos

mini.nvim

echasnovski/mini.nvim

A collection of 40+ small, focused Lua modules. Pick exactly what you need: mini.files, mini.ai, mini.pairs, mini.animate.

Use individual modules: require("mini.files").setup()

Distributions — Pre-built Configs

If building from scratch feels overwhelming, start with a distribution. They provide a full IDE-like experience out of the box. You can customize from there, or gradually learn how they work.

Distribution	Philosophy	Beginner-Friendly	Customizable	Best For
LazyVim	Batteries included, lazy.nvim-based, opinionated defaults	✓ Yes	Very High	Most users — great starting point
AstroNvim	Community-maintained, modular, lazy.nvim-based	✓ Yes	Very High	Community plugins, "AstroCommunity"
NvChad	Fast startup, beautiful UI, minimal base	Moderate	Medium	Speed-focused users who love pretty UI
kickstart.nvim	Single-file teaching config — read every line	✓ Best	Start here	Recommended for learning — understand everything
Custom (from scratch)	Build exactly what you need, nothing else	Hard	Total	Experienced users, minimalists

Recommendation: Start with kickstart.nvim (github.com/nvim-lua/kickstart.nvim) — it's a ~600 line commented init.lua that explains every decision. Once you understand it, migrate to LazyVim or build your own.

Best Practices & Learning Tips

Learn Vim motions first — before plugins

Run vimtutor in your terminal. Do it twice. Master hjkl, w/b/e, f/t, ciw, dd, yy, p before installing anything. Plugins amplify skills you already have.

Use kickstart.nvim as your starting config

Clone it, read every comment, run it. This teaches you why each option exists. Don't copy large configs you don't understand — you won't know how to debug them.

Install plugins one at a time

Add one plugin, learn it for a week, then add the next. Installing 50 plugins at once is overwhelming and leads to unmaintained bloat. Start with: LSP + Telescope + Treesitter + a colorscheme.

Set a leader key and be consistent

Use Space as leader (most popular). Group your keymaps logically: <leader>f = find, <leader>g = git, <leader>c = code, <leader>u = UI. Use which-key.nvim to document them.

Use :checkhealth regularly

Run :checkhealth after installing plugins or language servers. It diagnoses missing dependencies, incorrect paths, and configuration errors before they become mysterious bugs.

Keep your config in Git

Put ~/.config/nvim in a git repo. This lets you sync between machines, roll back bad changes, and track what you've changed. Commit often with descriptive messages.

Starter Plugin Set (Minimal but Powerful)

-- The essential 10 plugins to start with
return {
  -- 1. Colorscheme
  { "folke/tokyonight.nvim", lazy = false, priority = 1000 },

  -- 2. File finder
  { "nvim-telescope/telescope.nvim", dependencies = { "nvim-lua/plenary.nvim" } },

  -- 3. Syntax highlighting
  { "nvim-treesitter/nvim-treesitter", build = ":TSUpdate" },

  -- 4. LSP: server manager
  { "williamboman/mason.nvim", opts = {} },
  { "williamboman/mason-lspconfig.nvim" },
  { "neovim/nvim-lspconfig" },

  -- 5. Autocompletion
  { "hrsh7th/nvim-cmp" },
  { "hrsh7th/cmp-nvim-lsp" },

  -- 6. Git signs
  { "lewis6991/gitsigns.nvim", opts = {} },

  -- 7. Statusline
  { "nvim-lualine/lualine.nvim", opts = {} },

  -- 8. Keybinding help
  { "folke/which-key.nvim", opts = {} },

  -- 9. Auto-close pairs
  { "windwp/nvim-autopairs", event = "InsertEnter", opts = {} },

  -- 10. Commenting
  { "numToStr/Comment.nvim", opts = {} },
}

Performance tip: Run :Lazy profile to see which plugins slow down startup. Aggressively lazy-load everything — use event, cmd, or keys triggers instead of loading eagerly.

Learning resource: :help is incredibly comprehensive. :help usr_01.txt starts the official Vim manual. :Telescope help_tags makes it searchable.