AI was supposed to threaten intelligence.
It exposed how little judgement most systems ever required.

A few months back, I sat in a review where a junior engineer presented an architecture proposal. Clean diagrams, well-structured document, confident annotations. The first questions were answered fluently. Then we pushed into the edge cases: what happens when this service changes, how does it behave under unexpected load, why this particular approach over the alternatives?

“I’d need to check.”

Three times in the same conversation. The work looked senior-grade. The reasoning wasn’t there. When I asked what had informed specific choices, the honest answer eventually came: “Claude suggested it and it seemed right.”

I didn’t blame them. But I kept thinking about what had actually happened in that room.

A post from an old colleague, Ahmed , crystallised why. He was questioning whether intelligence and knowledge still define who we are, now that AI can produce answers faster than we can formulate questions. The idea itself isn’t new. But something about it stayed with me, because familiar markers of value stopped being rare, and that’s what the technology exposed.

Value was moving, and it was moving somewhere less comfortable.

What actually changed

AI made it uncomfortable by making intelligence-shaped output cheap.

Replacement would be a crisis, but repricing is permanent. For most of modern professional history, knowing things that others didn’t was a durable source of value. If you could produce analysis faster, design more coherently, or debug what others couldn’t, you were needed. Careers were built on being the expert in the room.

In fact, the expertise hasn’t disappeared. What’s changed is that access to expertise-shaped output is now abundant. Code still matters, but writing it no longer signals much. Architecture diagrams still exist, though generating one has become trivial. Analysis is everywhere, which makes any single instance of it less remarkable.

The first visible effect is devaluation, not replacement.

Juniors produce work that looks senior. Seniors feel their edge narrowing. Being “smart” becomes harder to see, and “experienced” carries less weight on its own. What looks like a capability crisis is actually a currency crisis. The coin that professionals built identity and career on has been debased.

People aren’t afraid of machines becoming smarter. They’re afraid of losing the thing their identity was attached to, of becoming ordinary.

The gap that doesn’t deflate

Back to that review, because that’s where ordinary showed up. The proposals were coherent. What they lacked was ownership.

AI generates options. Accountability belongs to a person. It can optimise locally and produce the diagram, but it cannot reason about what an organisation will actually resist, what a decision will cost eighteen months after delivery, or be accountable for any of it.

That accountability is judgement, and judgement is not a soft skill or a vague quality that experienced people accumulate. It is the willingness to make a call when the information is incomplete, own it when it turns out wrong, and explain the reasoning without hiding behind the tool.

In software architecture, the distinction between producing work and owning it is familiar. Getting a design on paper is rarely the hard part. The difficulty shows up in understanding what the system will tolerate, what the organisation will resist, and where the fragility hides. Quite often, the right answer is not to build at all. That conclusion doesn’t come from the tool. It comes from someone willing to defend it, sign their name to it, and live with what follows.

Value concentrates here because the gap between “looks right” and “is right for these conditions” is invisible to anyone not willing to own it.

From execution to direction

For years, owning it meant execution: how cleanly you implemented, how fast you delivered, how many patterns you could apply.

That’s AI: fast, precise, and tireless.

But execution is only one of the two things an architect does. The other is what Gregor Hohpe calls the elevator ride : moving between the engine room and the penthouse, translating between what the business needs and what the system can actually deliver, and owning the consequences of that translation.

AI reaches every floor. It can optimise infrastructure, generate business-facing proposals, and produce documentation for either audience. What it cannot do is take the ride with accountability. It cannot own the misalignment when the penthouse and the engine room diverge, or be the person who explains to the board why the system failed to deliver what the strategy required.

The value that concentrates is the willingness to hold both floors simultaneously and own what you told each of them.

When it matters, and when it doesn’t

This concentration is not universal.

Judgement commands a premium in specific conditions: decisions that are expensive to reverse, failure modes with catastrophic downside, consequences that surface long after delivery. In these environments, execution is rarely the constraint. Direction is.

There are also environments where speed matters more than deliberation: proofs of concept, short-lived tools, low-risk experimentation. Treating everything as a high-stakes architectural decision is its own failure mode. Part of the judgement is recognising where you actually are.

The objection worth taking seriously

That judgement cuts both ways: AI reasoning models can already weigh trade-offs, identify risks, and simulate consequences, and the gap keeps closing. So why assume this is durable?

Because accountability doesn’t transfer. Taleb’s point in Skin in the Game applies directly: reasoning without stakes is advice. The stakes belong to whoever signs their name to the decision, faces the client when it goes wrong, and explains to the organisation why this approach was chosen. That person is not the tool.

Judgement, in the sense that actually matters, is inseparable from the person who owns what follows. You can rent the reasoning. You cannot outsource the consequences.

Where this leaves the engineer

For that engineer, owning the consequences didn’t mean using less AI. It meant mastering the “why”: intent, consequences, direction rather than output. That means explaining why, defending under pressure, and owning what follows when it doesn’t go as planned.

That’s the trade: the comfort of execution for responsibility.

That’s what was missing in that room.