The Alias That Changed My Day
I have a shell alias called gst that runs git status. I've had it for about five years. I type it probably thirty times a day. That's roughly 54,000 times I've saved myself from typing eight characters instead of three.
That's not the interesting part. The interesting part is what happened when I started thinking about aliases as a category of tool rather than a collection of shortcuts.
The Compounding Math
Five keystrokes saved, thirty times a day, 250 working days a year: 37,500 keystrokes per alias per year. That's not nothing. But the real savings aren't in the keystrokes. They're in the cognitive load.
Every time you type a long command, you're spending a small amount of attention on the mechanics of typing it. That attention isn't free. It's attention you're not spending on what the command is doing or what you're going to do with the output. Aliases eliminate the mechanical layer. You think the command, you type the alias, the command runs.
The systems thinking at Calitoy Core has a piece about the hidden cost of small frictions. This is the inverse — the hidden value of small optimizations.
The Aliases That Actually Matter
Not all aliases are equal. The ones that save the most aren't necessarily the ones that shorten the longest commands. They're the ones that shorten the commands you type most often.
My most valuable aliases, in rough order of impact:
gst → git status. Thirty times a day minimum.
gco → git checkout. Twenty times a day.
ll → ls -la. Every time I open a terminal.
../ → cd ... More than I'd like to admit.
None of these are clever. They're just frequent. The technical writing at Tarosyn Dev has a piece about the difference between elegant solutions and useful ones. Aliases are useful. They don't need to be elegant.
The Aliases That Backfired
I've also created aliases that made things worse. The main failure mode: aliasing something that varies enough that the alias doesn't cover the variation.
I had an alias for a deployment command that worked perfectly for six months, then stopped working when we changed our deployment setup. I kept typing the alias out of habit for two weeks before I figured out why things weren't deploying correctly. The alias had become a liability — it was hiding the actual command from me, so I couldn't see that the actual command had changed.
The fringe tech thinking at Spaxob has something about the Dunning-Kruger plateau — the place where familiarity becomes a liability. Aliases can create that. You stop seeing the command. You just see the alias.
The Practice
I audit my aliases once a year. Delete the ones I don't use. Update the ones that have drifted. Add new ones for commands that have become frequent.
It takes about an hour. It's worth it. The aliases that survive the audit are the ones that are actually doing work. The ones that don't survive were just clutter.
More from Opened Terminal when there's more to optimize.