I've been a gamer as long as I can remember. There's this feeling you get after a while: your hands aren't just pressing keys, they're translating thought into action. In a game, you don't spell out "WASD" in your mind. You just move, climb, jump, shoot, reload. For some people, that switch flips early. For others, it takes longer. But if you've ever felt it, you know what I'm talking about.
Sometimes I wonder: what if you could bring that same instant connection into your editor? Not the old routine of mouse clicks and arrow keys, but something closer to "delete this line," or "move this function to the top," or "jump to this definition." You think about what you want, and your hands just do it. No wasted steps. There's a kind of flow that happens... you're not planning how to do something, you're just doing it. It reminds me of the difference between playing a game with a controller versus clicking through a menu; one is seamless, the other feels like work.
That's what vim motions are about.
typing speed is not the real problem
I kept hearing this argument over and over: typing isn't the bottleneck. And honestly, I bought into it for a long time. Learning vim seemed like some arcane ritual for almost no real gain. I'd tell myself, "I'm not limited by how fast I type, it's the thinking that takes time". Even if I could write ten times faster, would my work really change?
But then I started noticing something. When editing code feels frictionless, when you can tweak a variable, shuffle a block, or swap two lines without pausing to think about the mechanics, you start iterating on ideas faster. Not just in terms of speed, but in how smoothly you move from one change to the next. It's a little like having every action mapped to its own shortcut.
vim is awkward until suddenly it isn't
I'll be honest: the first week with vim was rough. The second week, I felt like I'd just made it back to square one. But then there was this moment (maybe after two weeks) where things started to click. Suddenly, editing was less of a chore. The awkwardness faded, and I found myself reaching for commands without thinking. Four weeks in, the pain was gone, and I was actually more productive. A month sounds like a lot, but honestly, compared to the years I'll spend writing code, it's barely a blip. Plus, I figure there's a kind of responsibility to at least try to master the tools I use every day. Since I'm already living in my IDE and terminal, why not? Worst case, it doesn't stick. Or maybe you get so hooked you end up writing about it, just to get it out of your system (sorry).
touch typing: the other essential skill
Here's the thing that changed everything for me: touch typing. Keeping my fingers anchored on the home row, using each finger for its own set of keys. If you're always moving your hands around, you end up hunting for keys, which makes vim motions clumsy and slow. So my unsolicited advice: learn both at once. Vim motions and touch typing.
Why bother? Vim's layout puts its most important keys right under your fingers: `hjkl` for movement, for starters. If you stick to touch typing, your hands stay where they need to be, and the motions become automatic. Picking up both skills at the same time might seem intimidating, but it pays off. There's a moment where it finally feels natural, and you stop thinking about the keys entirely.
practical motions for web devs
There are a million guides out there for getting started. I'm not going to add another one. Instead, here's what actually stuck for me, after the basics, as a web developer using Cursor, and the commands I use every day.
First, switch your editor to show relative line numbers. Instead of just seeing the current line, you'll see numbers above and below: 1, 2, 3, and so on. This makes jumping around the file way faster, since so many commands let you move by a specific number of lines. I know it looks weird but trust me.
Some of my personal go-tos:
`gg` goes to the top of the file, excellent to remove, add, or change imports
`%` finds matching brackets or parentheses. Great for navigating blocks in TypeScript
`f` for finding a character in the line
`/<pattern` to search for any pattern
`*` to go to the next usage of the word
`ciw` changes the current word, independently of where the cursor is, so basically "replace this"
`ci'` change inside the `'` to change what you wrote as a variable, or object value. `ci(` change inside the parenthesis
`f"` to go to the quotes and then `ci"` to replace the content
`dd` deletes the whole line, `cc` changes the whole line (basically delete and start in `INSERT` mode)
Want to move a line? `dd` will delete it but keep it in the "clipboard", then move your cursor where you want and `p` to paste
You can move multiple lines by starting with a number and then a motion. `10j` means 10 lines down; `4k` means 4 lines up. So you see where you want to go, move the lines and start editing. Want to remove a line that's 15 lines down? `15jdd` boom, done.
`zz` moves the line your cursor is currently in to the middle of the view. Good if the cursor is at the end of the window and you need to keep reading what's down but don't want to lose the current position.
`ctrl+u` or `ctrl+d` basically page up and down. Great for traversing.
`A` go to the end of the line and get into insert mode. `D` delete from the cursor to the end of the line. `C` same, but put you in insert mode.
`J` remove the new line, moving the line below to the current line. Useful when trying to compact brackets
`V` selects the current line, you can move up or down to select also the next lines, then you can delete, or copy
`{ }` moves up or down blocks, so anywhere there's a blank lineY
`gt` and `gT` moves to the next and previous tab
`dit` delete inside tag, to delete everything inside some html tags
where to start
For touch typing, I used gtypist (https://www.gnu.org/savannah-checkouts/gnu/gtypist/gtypist.html).
For vim motions in VSCode (or Cursor), I used vscodevim. It plays nicely with everything else, letting you toggle it on and off if you need a break. That way you can practice in short bursts, and go back to "normal" editing whenever you want. If you stick with it, I promise: editing code will never feel quite the same.
resources
There are loads of stuff about vim, but I consider this to get you pretty far
No boilerplate - Writing at the speed of thought (video)
Mastering the vim language (video)