Software engineering has always struggled with metrics.
We've measured:
Some of these are useful.
None of them measure the thing we actually hire senior engineers for.
Judgment.
As AI begins generating more code than any human ever could, this problem is about to become impossible to ignore.
For decades, writing software was expensive.
Today, generating software is becoming increasingly inexpensive.
Large language models can produce APIs, unit tests, infrastructure definitions, SQL queries, Kubernetes manifests, and Terraform modules in seconds.
That doesn't mean software engineering is solved.
It means the bottleneck has moved.
Imagine two engineering teams.
Both use the same AI tools.
Both generate code at roughly the same speed.
Yet one repeatedly ships stable systems while the other experiences outages, rewrites, and endless technical debt.
The difference isn't typing speed.
It's engineering judgment.
One team consistently asks better questions before implementation begins.
Those questions don't produce code.
They produce better decisions.
I've worked with engineers who could write astonishing amounts of code.
I've also worked with engineers who barely touched the keyboard during architecture discussions.
Guess which ones changed the trajectory of projects.
The most valuable engineers I've known rarely distinguished themselves through implementation.
They distinguished themselves by preventing bad decisions before anyone wrote code.
They saw hidden dependencies.
They challenged assumptions.
They recognized failure modes.
They simplified systems that everyone else wanted to complicate.
Their leverage came from reducing the amount of unnecessary engineering that followed.
This is why I think AI increases the value of senior engineers rather than decreases it.
If implementation becomes nearly free, then deciding what to implement becomes dramatically more important.
Imagine an organization where AI can produce a thousand implementation options before lunch.
The competitive advantage won't belong to the team generating the most code.
It will belong to the team selecting the best option.
Engineering judgment becomes the limiting resource.
This is a much harder question.
Judgment isn't captured by a single metric.
But we can observe behaviors that consistently correlate with good engineering decisions.
For example:
Those aren't productivity metrics.
They're reasoning metrics.
Imagine performance reviews that rewarded engineers for:
That's a different definition of engineering excellence.
One that's much harder to automate.
The software industry spent decades optimizing implementation.
Version control.
Continuous integration.
Automated testing.
Infrastructure as Code.
All of those made writing software faster and safer.
The next decade will likely optimize something different.
Not code generation.
Engineering judgment.
Organizations that learn to preserve, teach, and scale good judgment will consistently outperform organizations that merely generate more software.
Because code is becoming a commodity.
Good engineering decisions are not.
The future belongs to the teams that can tell the difference.