
AI Doesn't Take Showers
Why the code a machine writes in seconds still needs a human who lives with it for days
AI Doesn't Take Showers
Why the code a machine writes in seconds still needs a human who lives with it for days
There's a small, unglamorous ritual that a lot of us go through every morning without thinking much about it. Wake up, check the phone, eat something, sit down, and before doing anything else — reload the mental context. Skim yesterday's notes. Remember what you were building. Get your head back into the problem.
Then, somewhere in the shower, something clicks. Not because you were trying to solve anything — you were just standing there, half-asleep, letting the water do its thing. But that's exactly when the idea shows up. The fix for last night's bug. The realization about what you got wrong. The better way forward that wasn't there yesterday. And if it doesn't happen in the shower, it happens at 3AM, tangled up in a dream, or halfway through a coffee with a friend, or mid-scroll through some unrelated thread that suddenly clicks into place.
None of that is random. It only happens because of the depth of work underneath it — the hours spent wrestling with the nuances, sitting with a problem long enough that your brain keeps chewing on it even after you've walked away from the keyboard. The insight is a receipt for time already spent.
The Thing AI Can't Do
AI, meanwhile, is extraordinary at almost everything around that process. It writes code faster than any of us can type it. It explores ideas and explains them back in a fraction of the time we'd need. It catches mistakes we'd miss. It can take an entire codebase and rewrite it from one language to another and back again, without complaint.
But it doesn't take showers.
It doesn't sit with a problem after the work is done. It doesn't wake up at 3AM with a sudden realization about a decision it made hours earlier. It doesn't argue with itself over the what-ifs, or have a conversation over coffee that suddenly reframes the whole approach. The moment the code is written, that's it — the process that produced it is over, and so, in a real sense, is the model's relationship to it.
A human could, in theory, pick up where the AI left off and do all that slow, ambient thinking. But there's a catch: that human wasn't the one who actually sat with the code. They didn't internalize the dozens of small decisions, weigh the trade-offs, argue themselves in and out of three different approaches before landing on the fourth. The AI knew the code intimately — for the few minutes it was writing it. Then it moved on, and that knowledge simply evaporated.
The Code That Nobody Remembers
What's left behind is strange: working code with no memory attached to it. It exists, technically correct, sitting in the repo — but it's a relic of a process nobody retained. There's no one left to explain why it was built this way instead of that way, because there was never really anyone who struggled through it in the first place. No one debated the edge cases out loud. No one paced around a decision before committing to it. It just appeared, fully formed, the way a finished cake appears without anyone having tasted the batter.
That's a quieter, more insidious version of something a lot of teams already know the pain of: the cognitive debt that shows up whenever someone leaves a company and takes their unwritten knowledge with them. Except now it's not tied to a person walking out the door — it's baked into every single change, all the time, because the "person" who wrote it never actually carried the knowledge to begin with.
Why This Matters
None of this is an argument against using AI to write code — it's simply a reminder of what the tool is, and isn't, doing for you. It can produce the artifact. It cannot produce the internalized understanding that usually comes bundled with the artifact, for free, when a human writes it themselves. That understanding — the "oh, that's why it's like this" — has always been a side effect of the slow, sit-with-it thinking that happens away from the screen. In the shower. At 3AM. Over coffee.
If we're not careful, we end up with faster code and slower understanding — codebases that ship quickly but that nobody actually knows. And knowledge you don't have is a debt you inherit later, usually at the worst possible time.
Maybe the real skill going forward isn't writing code faster. It's making sure someone — anyone — still takes the shower.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article