15 Vim Tips You Need To Know

Published at Feb 26, 2025

9 min read
#vim
#neovim
#workflow
#productivity

Vim is an incredibly powerful text editor, and once you get the hang of it, it can seriously level up your productivity. You might already know the basics, but there are tons of hidden tricks that can make your workflow smoother and faster. While learning Vim, I picked up a lot of game-changing techniques from Practical Vim by Drew Neil—an amazing book that’s packed with insightful tips for both beginners and advanced users. In this post, I’ll share 15 advanced Vim tips that go beyond the usual commands. Each one comes with clear explanations, real-world examples, and practical ways to use them in your coding routine. Whether you’re looking to speed up navigation, edit more efficiently, or just feel more at home in Vim, these tips will help you get there.

I highly recommend you to open a Neovim or Vim session and try these commands as you read through them. It will help you understand and remember them better.

Structure

1. Repeat Last Ex Command with @:

The @: command allows you to repeat the last Ex command (commands that start with :). This is particularly useful when you need to execute the same command multiple times without retyping it.

Example: Suppose you replaced a variable name in one part of your code using :s/old_var/new_var/. If you need to perform the same replacement elsewhere, simply type @: to repeat the command.

    :s/old_var/new_var/  " Replaces 'old_var' with 'new_var'
    @:  " Repeats the substitution command

Real-World Use Case: When refactoring code, you might need to rename a variable or function multiple times. Instead of manually typing the substitution each time, use @: to save time and effort.

2. Delete and Insert with s and Replace with r

The s command deletes the character under the cursor and switches to insert mode, while r replaces the character under the cursor without entering insert mode.

Example: If you have the text print("Hello") and the cursor is on the H, pressing s will delete H and allow you to type a new character immediately. Alternatively, r followed by a character (e.g., rX) will replace H with X.

    print("Hello")
    s  " Deletes 'H' and enters insert mode
    rX " Replaces 'H' with 'X'

Real-World Use Case: When fixing typos or replacing characters in code, s and r are faster than using x followed by i.

3. Repeat Last Substitute Command with & and Search with *

The & command repeats the last substitute command, while * searches for the word under the cursor. These commands are great for repetitive tasks.

Example: After running :s/foo/bar/, you can use & to repeat the substitution elsewhere. Similarly, if the cursor is on the word function, pressing * will search for all instances of function.

    :s/foo/bar/  " Replaces 'foo' with 'bar'
    &  " Repeats the substitution
    *  " Searches for the word under the cursor

Real-World Use Case: When cleaning up code or navigating large files, & and * save you from repetitive typing and searching.

4. Increment and Decrement Numbers with C-a and C-x

The C-a (Ctrl + a) command increments the number under the cursor, while C-x (Ctrl + x) decrements it. This is useful for quickly adjusting numerical values.

Example: If you have the number 42 and the cursor is on it, pressing C-a will change it to 43, and C-x will change it back to 42.

    42
    C-a  " Increments to 43
    C-x  " Decrements back to 42

Real-World Use Case: When working with counters, indices, or configuration values, C-a and C-x make it easy to adjust numbers without leaving normal mode.

5. Change Case with gu and gU

The gu operator makes text lowercase, while gU makes it uppercase. Combine these with motions like w (word) or $ (end of line) for quick case changes.

Example: To make the current word lowercase, use guw. To make the entire line uppercase, use gU$.

    guw  " Makes the current word lowercase
    gU$  " Makes text from the cursor to the end of the line uppercase

Real-World Use Case: When standardizing variable names or formatting strings, gu and gU help you quickly change case without retyping.

6. Insert Mode Shortcuts: C-h, C-w, and C-u

In insert mode, C-h deletes a character (backspace), C-w deletes a word, and C-u deletes the entire line.

Example: If you’re typing and make a mistake, use these shortcuts to quickly correct it.

    C-h  " Deletes the character before the cursor
    C-w  " Deletes the word before the cursor
    C-u  " Deletes the entire line before the cursor

Real-World Use Case: These shortcuts are invaluable when editing long lines of code or fixing typos without leaving insert mode.

7. Insert Normal Mode with C-o and Paste with C-r{register}

The C-o command temporarily switches to normal mode for a single command, then returns to insert mode. In insert mode, C-r followed by a register name pastes the content of that register.

Example: If you’re in insert mode and need to delete a word, use C-o dw. To paste from the default register, use C-r ".

    C-o dw  " Deletes a word and returns to insert mode
    C-r "   " Pastes the default register content

Real-World Use Case: When writing or editing code, C-o and C-r{register} allow you to perform quick normal-mode operations and paste text without disrupting your flow.

8. Evaluate Expressions with C-r = and Print ASCII Value with ga

In insert mode, C-r = opens a prompt where you can type an expression. Vim evaluates the expression and inserts the result. The ga command prints the ASCII value of the character under the cursor.

Example: If you need to calculate a value, use C-r =. To print the ASCII value of a character, use ga.

    C-r = 5 + 5  " Inserts 10
    ga           " Prints the ASCII value of the character under the cursor

Real-World Use Case: When writing code that involves calculations or debugging special characters, C-r = and ga are incredibly useful.

9. Visual Mode Shortcuts: V, C-v, and gv

The V command enables line-wise visual mode, C-v enables block-wise visual mode, and gv reselects the last visual selection.

Example: To select the current line, press V. To select a vertical block of text, press C-v. To reselect the last visual selection, press gv.

    V    " Selects the current line
    C-v  " Enables block-wise visual mode
    gv   " Reselects the last visual selection

Real-World Use Case: When working with multi-line code blocks or columns of data, these shortcuts make selection and manipulation effortless.

10. Advanced Navigation: e, %, and Ranges

The e command moves to the end of a word, % jumps to the matching bracket, and ranges like 2,5 or .,$ allow you to specify lines for commands.

Example: To move to the end of the current word, use e. To jump to the matching bracket, use %. To apply a command to lines 2 to 5, use 2,5.

    e    " Moves to the end of the current word
    %    " Jumps to the matching bracket
    :2,5s/foo/bar/  " Replaces 'foo' with 'bar' in lines 2 to 5

Real-World Use Case: When navigating or editing code, these commands help you move quickly and apply changes precisely.

11. Toggle Visual and Select Mode with C-g

In visual mode, C-g toggles between visual mode and select mode. This is useful for fine-tuning selections.

Example: If you’ve selected text in visual mode, press C-g to switch to select mode.

    C-g  " Toggles between visual and select mode

Real-World Use Case: When selecting text for copying or editing, C-g gives you more control over your selections.

12. Use Marks for Navigation

Marks allow you to save and jump to specific locations in your file. Use m{a-z} to set a mark and '{a-z} to jump to it.

Example: To set a mark a at the current cursor position, use ma. To jump to mark a, use 'a.

    ma  " Sets mark 'a' at the current position
    'a  " Jumps to mark 'a'

Real-World Use Case: When working on large files, marks help you quickly navigate between important sections of code.

13. Use :global for Batch Operations

The :global command allows you to run commands on lines that match a pattern. For example, :g/foo/d deletes all lines containing foo.

Example: To delete all lines containing TODO, use :g/TODO/d.

    :g/TODO/d  " Deletes all lines containing 'TODO'

Real-World Use Case: When cleaning up code or performing batch operations, :global is a powerful tool.

14. Use :normal to Execute Normal Mode Commands

The :normal command allows you to execute normal mode commands from the command line. For example, :%normal A; appends a semicolon to every line.

Example: To append a semicolon to every line, use :%normal A;.

    :%normal A;  " Appends a semicolon to every line

Real-World Use Case: When making repetitive edits, :normal saves you time by automating normal mode commands.

15. Use Macros for Complex Edits

Macros allow you to record and replay a sequence of commands. Use q{a-z} to start recording, q to stop, and @{a-z} to replay.

Example: To record a macro that deletes a word and moves to the next line, use qa to start recording, perform the actions, and q to stop. Replay the macro with @a.

    qa  " Starts recording macro 'a'
    dw  " Deletes a word
    j   " Moves to the next line
    q   " Stops recording
    @a  " Replays macro 'a'

Real-World Use Case: When performing complex or repetitive edits, macros are a game-changer. I will soon post a detailed guide on how to use macros effectively! Keep an eye out for it.

Shoutout to Practical Vim

If you really want to get better at Vim, I can’t recommend Practical Vim by Drew Neil enough. This book is packed with useful insights, breaking down everything from the fundamentals to advanced techniques with clear explanations and real-world examples. Whether you’re just starting out or already comfortable with Vim, it’s a game-changer

Final Thoughts

Vim gets better the more you use it. The tips we’ve covered can help you work faster and more efficiently, but the real magic happens when you keep experimenting and making Vim your own. Stay curious, keep practicing, and you’ll uncover even more ways to improve your workflow.

Happy coding, and enjoy the journey!

← Back to Blog