The Craft You Mourn Was the Thinking, Not the Typing — and the Thinking Is Still Yours Unless You Give It Away
June 21, 2026 · Liu Weipeng, Dark Time~5 min read
There is a grief moving quietly through the people who write software. You can read it on Hacker News this spring — threads with titles like "We mourn our craft" and "The next two years of software engineering," where senior engineers say, half-ashamed, that something they loved is dying. The easy read is that they miss typing: that the machine took the keyboard and with it the joy. But that's not what the honest ones are mourning. Read closely and the loss has a different shape, and naming it correctly is the whole difference between grieving well and grieving for the wrong thing.
What the keyboard was never about
One developer in those threads put his finger on it: what made computing satisfying was that a computer was "completely scrutable and reason-able." You could hold the whole machine in your head. Press a key, predict the result, and be right — and when you were wrong, the gap was a puzzle you could chase down to the line. That predictability was a kind of intimacy. LLM-driven work can feel like the opposite: you ask, something appears, it works, and you couldn't say exactly why. It arrives like a gift from a stranger. The mourners aren't pining for sore wrists. They're mourning control, scrutability, the sense that the system was theirs to understand — a model of the machine they could carry around in their own head.
The craft was never in your fingers
Here's where the Chinese programmer Liu Weipeng, writing years ago in Dark Time, turns out to have already answered the grief. His core claim is that the real work of a thinker never happens at the keyboard at all. It happens in what he calls dark time — the invisible hours spent turning a problem over while you walk, shower, ride the train. Nothing shows on screen. No keystrokes. Yet those are the hours when the understanding actually forms, compounds, and hardens into a model you can hold and carry to the next problem. By that measure the typing was always the cheap part. It was the visible exhaust of thinking that had already happened somewhere darker. So if a machine now does the typing for you, it has taken the part that was never the craft. The craft — the held understanding — it cannot touch.
What programmers mourn is control, scrutability, and a model of the machine they could hold. AI removes the keystrokes — a thin loss, since the typing was never the craft. The deep understanding is lost only one way: by approving code you don't grasp. Framework: Liu Weipeng, Dark Time. Real basis: the May–June 2026 Hacker News "We mourn our craft" discussion. A reflection, not career advice.
The one way you actually lose it
But there is a trap, and it is the part worth being honest about. The understanding is safe from the tool — not safe from you. The dangerous move is the one that feels like progress: accept code you don't understand, ship it because the tests pass, and move on. Do that enough and the held model in your head quietly empties out. Call it understanding debt — the same shape as technical debt, except what's deferred is your own comprehension, and the interest comes due the day something breaks and you realize you're a tourist in your own system. The machine never reached into your mind and deleted anything. You stopped doing the dark-time work, and a model you don't maintain simply fades. The grief on those forums is real. But the precious thing isn't taken; it's only ever given away.
This isn't a longing for the old days
To be clear, none of this is nostalgia for hand-compiling on a 1990s BBS, and the case falls apart the moment it curdles into that. Rejecting the tool to feel artisanal is just a slower way to lose. The point isn't to refuse the help with the typing — that part was genuinely tedious, and good riddance. The point is to be precise about which part to defend. Defend the scrutable model. Spend the keystrokes the machine just handed back to you not on generating three more features you'll also never understand, but on understanding the one it already wrote. Same tool, opposite outcome; the difference is entirely in where you point the time you saved.
What this means for you
So the next time you feel that small grief watching an AI write what you used to write, ask which thing you're actually losing. If it's the typing, let it go; you were mourning a chore. If it's the understanding, that one is still in your hands, and no model can keep it for you. The honest move is almost boring in its simplicity: refuse to merge what you can't explain. Read the generated diff until you could have written it. Spend your reclaimed dark time on comprehension, not on output. The craft was never the clatter of keys. It was the quiet model of the machine you carried in your head — and that, you only lose if you stop bothering to build it.
The machine can write your code, but it cannot understand it for you. Approve what you don't grasp, and you hand away the only part that was ever the craft.
Mourn the typing if you like. The thinking is still yours — until the day you decide it isn't worth doing.
Source: framework from Liu Weipeng, Dark Time (the real work is the invisible thinking, not the keystrokes). Real-world basis: the May–June 2026 Hacker News discussion around "We mourn our craft" and "The next two years of software engineering," where developers named control, scrutability, and understanding — not typing — as what they mourn. A reflection, not career advice.
所以下次，当你看着 AI 写出你从前会写的东西、心里掠过那点小小的悲伤，先问问自己究竟在失去什么。若是打字，放手吧，你哀悼的不过是一件杂务。若是理解，那一件仍在你手里，没有哪个模型能替你保管。诚实的做法，简单到近乎无趣：拒绝合入你解释不了的东西。把生成的 diff 读到——你本可以自己把它写出来。把夺回的那段暗时间，花在弄懂上，而不是花在产出上。手艺从来不是键盘的咔哒声。它是你揣在脑子里那个安静的机器模型——而它，只在你懒得再去搭建时，才会丢。