I've been writing software for ten years. Last week I needed to extract a .tar.gz, sat there with my cursor blinking, and could not for the life of me remember the flag order. Is it -xzf? -xvf? So I Googled "extract tar gz" — for what felt like the thousandth time in my career.
If you've done this — with tar, with kubectl get pods -o, with awk, with find's argument order, with the exact flag to make curl follow redirects — I want to tell you something that took me a decade to accept:
That is not a knowledge problem. It's a memory-systems problem. And it's fixable from first principles.
First principle #1: your brain is supposed to forget
In the 1880s Hermann Ebbinghaus memorized nonsense syllables and tracked how fast he forgot them. The result is the forgetting curve, and it's brutal: without reinforcement, you lose the majority of new information within days. Not because you're tired or old or "bad at memorizing." Because forgetting is a feature. A brain that retained every command flag with equal priority would be a brain drowning in noise.
So the default state of any fact you learned once and didn't revisit is: gone. The kubectl flag you looked up during an incident at 2am in March is not in your head in May. The system worked exactly as designed.
The mistake is thinking the fix is "try harder" or "have more experience." Ten years of experience did not stop me Googling tar. Experience doesn't beat the forgetting curve. Nothing beats it except deliberately fighting it.
First principle #2: recognition is not recall
Here's the distinction that reorganized how I think about my own competence.
- Recognition is "oh, that one" when you see the answer. It's passive. It feels like knowing.
- Recall is producing the answer from an empty prompt. It's active. It is knowing.
When you Google a flag and go "ah yes, -o wide, of course," that warm feeling of familiarity is recognition. It is not recall. And the gap between them is the entire difference between someone who can run the system and someone who can run the system as long as the internet is up and the page still exists.
This matters more now than it ever has, and here's the uncomfortable part:
First principle #3: your tools are quietly atrophying the muscle
Autocomplete, Copilot, ChatGPT, Stack Overflow — they're recognition machines. They hand you the answer the instant you feel the itch of not-quite-knowing. Every time they do, you get the task done and you skip the one act that would have moved the fact from recognition into recall: retrieving it yourself, from nothing, and being right.
This is a genuinely good trade for things you'll do once. It is a genuinely terrible trade for the 50 commands and 30 concepts that are the actual core of your job — the ones you'll need at 3am during an incident when you do not have the patience to prompt your way to an answer and the cost of being slow is measured in downtime.
AI didn't make us dumber. It made us outsource recall, and recall that isn't practiced decays on schedule. The forgetting curve doesn't care that you have a very good autocomplete.
First principle #4: the fix is mechanical, not motivational
This is the part I love, because it means you don't need discipline or talent. You need a schedule.
Two mechanisms, both boring, both proven:
Active recall. Don't re-read the kubectl cheat sheet. Test yourself. "What flag shows the node a pod is scheduled on?" — produce it from memory, then check. The retrieval attempt itself is what builds the memory. Re-reading builds recognition (the fake kind). Testing builds recall (the real kind).
Spaced repetition. Review each fact right before you're about to forget it, and stretch the interval each time you get it right. This is the SM-2 algorithm, and the logic is almost insultingly simple:
You recall it correctly → push the next review further out (1d → 6d → 16d → 40d → …)
You blank on it → reset the interval, see it again tomorrow
You're surfing the forgetting curve on purpose — catching each fact at the last useful moment instead of letting it fall off or wastefully drilling stuff you already own. A few minutes a day, and the 50 commands that actually matter move into permanent recall while the long tail you genuinely should Google stays Googleable. That's the whole trick. There's no willpower in it.
Apply it to the stuff you can't afford to Google
The move isn't "memorize the man pages." It's to pick the load-bearing knowledge and put that on a spaced-repetition schedule:
- The flags you reach for during incidents (
kubectl,journalctl,dig,ss). - The failure modes — what a
CrashLoopBackOffactually means and the three things that cause it. - The decision knowledge — when to use a StatefulSet vs a Deployment, when a retry needs a circuit breaker, why your p99 and your average disagree.
This is the knowledge that separates "I can operate this" from "I can recognize this when shown." It's also exactly the knowledge AI is happiest to hand you for free, which is precisely why it's the knowledge quietly rotting in your head right now.
I got tired enough of re-Googling tar that I built spaced repetition for DevOps and SRE — the commands, the failure modes, the concepts — on the SM-2 schedule above, so the core stops falling off the curve: hamchops.com.
But honestly, the tool is secondary. The idea is the thing I wish someone had told me ten years ago: you were never bad at this. You were just fighting the forgetting curve with no system, and your tools were quietly taking the one rep that mattered.
Give yourself the rep back.
What's the one command you've Googled more times than you'd admit out loud? Mine's tar. Drop yours below — I'd bet the list is shorter and more universal than any of us expect.