Vim

Vim is a highly configurable modal text editor (“Vi IMproved”).

Fast keyboard-centric editing, composable commands, and low-resource remote usability.

Different modes separate text insertion from navigation and command execution.

Normal, Insert, Visual, Command-line, Select, Ex (practical core: first four).

Default mode for navigation, operators, and text manipulation commands.

Mode where typed keys insert text.

Mode for selecting text ranges for subsequent operations.

Ex command entry using :, /, ? prompts.

i (before cursor), a (after), o (new line below), etc.

Press Esc.

:w

:q

:wq or ZZ.

:q!

h left, j down, k up, l right.

w (start), e (end).

b

0 (start), $ (end).

gg and G.

{N}G or :N.

x

dd

yy

p / P.

u

Ctrl-r.

.

Turns one edit into many with minimal keystrokes.

/pattern

?pattern

n / N.

r<char>.

ciw (change inner word).

dw or daw depending context.

Action like delete/change/yank applied to motion/text object.

Cursor movement defining range for operators.

Semantic unit like word, sentence, quotes, brackets.

d$ delete to end of line.

di" delete inside quotes.

Number before command repeats it (e.g., 5j).

Named storage for yanks/deletes/macros.

Most yank/delete operations use unnamed register.

V selects whole lines.

Ctrl-v rectangular/block selection.

>> and << (or > / < with selections/motions).

Show absolute line numbers.

Show relative line numbers for efficient jumps.

Count-based vertical motions become faster and more accurate.

Built-in documentation system.

Using Insert mode for most navigation/editing.

Relying only on arrow keys and mouse.

Learn motions + operators + text objects + dot repeat.

Write often and understand undo/redo confidently.

Map Caps Lock to Esc (common optimization).

Keep simple .vimrc with only essential settings.

Use /, n/N, and simple substitutions.

Think in transformations, not character-by-character edits.

Keep shared configs portable across machines.

Practice core commands daily before adding plugins.

Master Normal mode fluency first.

Substitute all matches in file.

Use c flag: :%s/old/new/gc.

Select text then use :s/.../.../ range.

\v simplifies regex escaping syntax.

Named bookmarks to jump back to positions.

m{a-z} then 'a or `a.

Single quote jumps line; backtick jumps exact column.

History of major cursor jumps.

Ctrl-o back, Ctrl-i forward.

History of edit locations.

g; and g,.

Capture key sequence into register for replay.

q{reg} start, q stop.

@{reg}, repeat with count.

Design deterministic cursor position and idempotent edits where possible.

"_ discard deletions without overwriting yank registers.

Preserve valuable yanked content while deleting.

Usually "+ (and/or * depending platform).

Run Ex command on lines matching pattern.

:g/error/d delete lines containing “error”.

Inverse global (operate on non-matching lines).

In-memory file content object.

Buffer is content; window is viewport to a buffer.

Collection/layout of windows (not synonymous with file).

:split and :vsplit (or Ctrl-w shortcuts).

Ctrl-w h/j/k/l.

Ctrl-w +, Ctrl-w -, Ctrl-w >, Ctrl-w <.

Global list of locations (compiler/grep/lint results).

Window-local variant of quickfix.

Fast iterative navigation through errors/matches.

Populate quickfix with search tool results.

Run build command and parse errors into quickfix.

Execute command over quickfix entries/files.

Collapse/expand code regions.

za toggle, zR open all, zM close all.

Undo history survives editor restart (when enabled).

Saved workspace (windows/tabs/buffers) restorable later.

File-embedded editor settings (use cautiously for security).

Allow buffer switching without forcing saves.

Trigger actions on editor events (BufWrite, FileType, etc.).

Custom keybinding to commands/sequences.

Non-recursive normal-map vs recursive map behavior.

Prevents accidental remap loops/chains.

Custom prefix key for personal mappings.

Secondary prefix usually for filetype-specific mappings.

Install/update/load Vim plugins.

Adding many plugins without measurable workflow benefit.

Introduce one plugin at a time for clear pain points.

Complex .vimrc without comments/structure/version control.

Group settings by purpose and modularize logically.

Profile startup and lazy-load heavy plugins.

Audit plugins/scripts and avoid untrusted modelines.

Keep reproducible config and backup of dotfiles.

Track recurring manual edits and convert to mappings/macros.

Most edits are composable commands, not repetitive keystrokes.

Share minimal editor-agnostic conventions for team scripts/tooling.

Treat editor config like software project.

Deliberately practice text objects and macro workflows.

Use quickfix-driven multi-file edit patterns.

Test config changes incrementally to avoid workflow breakage.

Ensure terminal and GUI Vim behaviors are aligned where possible.

Document non-obvious mappings and workflow decisions.

Prefer clarity and predictability over clever key tricks.

Optimize highest-frequency editing paths first.

Build a small, stable, high-leverage command toolkit.

Vim’s scripting language for automation, plugins, and configuration logic.

Neovim commonly uses Lua for modern plugin/config performance ergonomics.

Encode repeatable editing workflows as commands/functions.

Defining domain-specific semantic edit ranges.

State waiting for motion/text object after an operator key.

Enables creation of powerful composable custom operators.

Keymap evaluating expression at runtime for context-aware behavior.

:normal uses mappings; :normal! bypasses mappings.

Batch execute commands across arglist/buffers/windows/tabs.

Search -> quickfix list -> scripted edits -> verification passes.

Fast project-wide search feeding quickfix/location workflows.

Language-aware navigation, diagnostics, rename, references, code actions.

Combines semantic code intelligence with fast text transformations.

Syntax tree parsing enabling richer highlighting/text objects/motions.

Run external commands without blocking UI responsiveness.

Maintains flow during lint/build/test operations.

Set max acceptable launch latency to protect iteration speed.

Profile, remove redundant plugins, defer filetype-specific loads.

Organize mappings under leader prefixes by domain/action.

Prefer consistent mnemonic patterns over arbitrary shortcuts.

Use named registers/macros deliberately for structured transformations.

Macros dependent on fragile cursor positions without guards.

Anchored searches, sanity checks, and repeat-safe edit logic.

Same command sequence yields predictable output regardless minor context.

Improves reproducibility for shared demos/pairing/runbooks.

Reliable SSH editing without heavy GUI dependencies.

Keycode/clipboard/color behavior differences across terminals/OS.

Standardize TERM settings, test mappings, and fallback keybinds.

Accidental copying of secrets into global clipboard history.

Use dedicated registers/temporary buffers and avoid persistent clipboard for secrets.

Malicious or compromised plugin code execution.

Pin versions, use trusted sources, review update diffs/changelogs.

Automated checks ensuring config validity/format/smoke startup.

Prevents broken setup across machines.

Over-customizing until default Vim knowledge no longer applies.

Minimal, documented customizations preserving core Vim grammar.

Cheatsheets + recorded macros/workflows + pair-editing sessions.

Prevent repetitive strain with balanced keymaps and typing posture.

Reduce pinky strain, remap frequent combos, leverage home-row motions.

Every powerful edit should be undoable and verifiable.

Low-latency editing loop beats feature overload.

Treat plugins/config/scripts as executable code requiring trust controls.

Version, review, and document editor automation artifacts.

Compose primitives (motions/operators/text objects) into scalable workflows.

Share portable practices, not environment-specific lock-in.

Automate repetitive edits across files via quickfix + scripted commands.

Depth in fundamentals outperforms endless shortcut accumulation.

Measure success by reduced friction and faster accurate edits.

Continuously prune config complexity that no longer pays value.

Integrate LSP/search/build tools without sacrificing modal fluency.

Be effective in minimal environments (remote shells, rescue systems).

Prefer explicit readable mappings over clever hidden magic.

Evolve config intentionally with measurable workflow gains.

You describe edits as language constructs, not key memorization.

Vim excellence is composable, repeatable, and disciplined editing fluency.