The Skills That Were Always the Job

Reading back through what changes and what doesn't, one pattern holds: almost nothing on the durable list is new. The skills that appreciate as implementation gets cheap are the ones experienced engineers always said mattered most, and that the job's economics didn't previously reward proportionately.

What the durable list contains

Understanding systems deeply. Holding a real model of how things work — what's load-bearing, where failures propagate, what a change touches. Always the difference between someone who could debug hard problems and someone who couldn't.

Knowing what's worth building. Always the highest-leverage judgment in software, and always the thing engineers said they wished they had more say in.

Precision about requirements. The discipline of knowing exactly what should happen, including the cases nobody mentioned. Always what separated projects that went smoothly from ones that didn't.

Verification. Caring whether something is actually right rather than apparently right. Always the mark of engineers people trusted.

Taste. Recognizing which solution shapes go wrong before you can articulate why. Always what distinguished senior judgment.

Knowing the domain. Always what made technical decisions good rather than merely defensible.

Accountability. Owning whether it worked. Always what people meant by seniority, whatever the title said.

Why they were undervalued before

Not because anyone disagreed — because implementation was scarce enough to dominate the economics.

When producing working code was expensive, being fast and reliable at it was the constraint, and the constraint gets rewarded. The judgment skills were what you also wanted, valued in principle and measured less directly. Promotion committees counted output. Interviews tested implementation. The advice to develop judgment was sound and the incentives pointed elsewhere.

→ Removing the constraint doesn't create new value in judgment. It reveals what was there, by removing the thing that was crowding it out of the measurement.

💡 The genuinely new part

Being fair, a few things are actually new rather than revealed:

Reviewing at volume, where the defects are plausible rather than obvious. The skill is related to code review and the failure mode is different — you're looking for wrong assumptions rather than wrong-looking code.

Specifying for a literal reader that won't ask a clarifying question and won't fill gaps from context.

Directing rather than doing, at every level rather than only in senior roles.

Knowing when the model is out of its depth — a calibration skill with no real precedent.

Those are additions. The rest of the list is old.

What this implies

The advice was always right. Anyone who spent the last decade building depth, learning the domain, developing judgment, and owning outcomes is well positioned, and didn't need to predict any of this.

The transition is a re-weighting, not a replacement. For most people it means their existing strengths matter more and one of their skills matters less — which is a milder change than the discourse suggests.

⚠️ It's harder to acquire these than it was. The judgment came from doing the work that's now delegated. That's the genuinely difficult problem in this whole shift, and it needs deliberate attention rather than assuming the pipeline still works.

It's a better job in some ways. More time on what's worth building, less on mechanical translation. Whether that's an improvement is individual — and for people who chose the field for the craft, it's a real loss alongside the gain.

The takeaway

The durable skills are the ones experienced engineers always named: understanding systems, knowing what's worth building, precision about requirements, verification, taste, domain knowledge, and accountability. They didn't become valuable — they became measurable, once the thing crowding them out got cheap. Which means the advice hasn't changed, the incentives finally point at it, and the hard part is that these skills were built by the work now being delegated.