My instincts are miscalculated. I can feel it.
I have been writing software and operating systems for long enough to have built up a library of shortcuts — not the bad kind, the useful kind. When something takes three days, you stop re-evaluating whether it should take three days. You just factor it in. That’s experience. That’s what seniors are selling when they sit in a room and call something “complex.” The problem is that a large chunk of those shortcuts are now wrong, and I don’t know which ones yet.
Marc Brooker put it better than I can. In My heuristics are wrong. What now?, he calls AI an “extinction-level event for rules of thumb.” That phrase landed hard when I read it. Not because it’s dramatic — because it’s precise.
The rules of thumb that experienced engineers have built up over decades are being disrupted. We’re not bobsledding anymore.
The Cool Runnings metaphor in that post is worth sitting with. You have a senior engineer who used to bobsled. Knows the physics, knows the track, knows where the dangerous curves are. But if you change the sport, all that track knowledge is not transferable. The curve is in a different place now. The physics shifted. And the person who trained to race on ice is confident in exactly the wrong things.
Kent Beck’s frame is the structural version of the same idea. Pere Villega captures it well in Code Is Cheap Now, And That Changes Everything: Beck says 90% of your current skills go to zero, 10% go up 1000x. The 10% is vision, milestones, managing complexity under uncertainty. Not syntax. Not remembering which flags to pass. Not the implementation patterns you internalized over years of repetition. The thing that took you the longest to learn — and that you probably can’t even fully articulate — that’s what still matters.
The uncomfortable part is that the 90% is where most of your confidence lives.
Marc Brooker wrote a companion piece about what this means for junior engineers, and I think he inverted the question in an interesting way. In What about juniors? he points out that juniors come in knowing they need to learn. That’s their baseline. They don’t have miscalibrated priors. Seniors carry the burden of unlearning, which is harder than learning because you don’t know which beliefs are load-bearing and which ones are just habit.
I have noticed this in myself. I’ll start a task with AI and feel resistance before I can explain why. Something will feel wrong. Then I’ll check, and half the time the resistance was legitimate signal — the approach had a real problem. But the other half, the resistance was just familiarity with a harder way. That 50/50 is not good enough. I can’t tell the difference between my intuition and my bias without actually running the experiment. That’s a strange place to be after this many years.
The Jepsen Notes piece on architects picking up the hammer describes this as the optimistic version of the same story. The senior person who has drifted away from building, rediscovering what it feels like to be close to the work because AI made it tractable again. I bounced between ops and dev my whole career, never fully climbed the ladder that takes you away from the code. Maybe that’s why this moment feels more like recalibration than re-entry for me. But I recognize the shape of it.
Will Larson writes carefully about what senior engineering roles actually cost — the coordination overhead, the review cycles, the distance from implementation that accumulates slowly until you’re mostly managing information rather than creating it. Apenwarr made a similar point bluntly: every layer of review makes you 10x slower. The architect-picks-up-the-hammer thing is appealing partly because it suggests AI can compress that distance again. Whether that’s real or just feels real, I’m not sure yet.
What I keep coming back to is the Wellington quote Brooker surfaces: engineering is doing well with one dollar what any bungler does with two. If AI handles implementation cheaply, then the discipline shifts earlier. The judgment about what to build, why, in what order, with what tradeoffs — that reasoning now needs to happen before you write a line, not during. Juniors need to get to that reasoning earlier than the previous generation did. Seniors need to stop confusing that reasoning with their implementation reflexes.
I don’t have a clean resolution here. This is not a post where I figured it out and I’m reporting back. I’m watching my own instincts closely right now, trying to distinguish earned pattern recognition from accumulated muscle memory that no longer matches the terrain. Some of it is transferable. Some of it is the ice track that isn’t there anymore.
The honest work is figuring out which is which before you bet on the wrong one.
Practical lessons on shipping software, straight to your inbox. No fluff.