AI doesn’t threaten intelligence.
It exposes how little judgement most systems have.

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, not because of the technology, but because of what it exposes when familiar markers of value stop being rare.

This is a story about value moving somewhere less comfortable.

What actually changed

AI hasn’t replaced intelligence. It’s made its outputs 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.

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, but 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. The proposals were coherent. What they lacked was ownership.

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

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, this distinction 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.

This is where value will concentrate. Not because judgement is rare by nature, but because the gap between “looks right” and “is right for these conditions” has become invisible to anyone not willing to own it.

From execution to direction

For years, technical professionals were judged on execution: how cleanly they implemented, how fast they delivered, how many patterns they could apply.

AI excels at execution: 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 can work at any floor individually. 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. It cannot 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 that are asymmetric, 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

AI reasoning models can weigh trade-offs, identify risks, and simulate consequences. The gap will keep closing. So why assume this is durable?

Because accountability doesn’t transfer. Reasoning without skin in the game, as Taleb puts it, is advice. Someone eventually 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 junior engineer

The path forward for that engineer didn’t involve using less AI. It involved mastering the “why”: intent, consequences, direction rather than output. Being able to explain why, defend under pressure, and own what follows when it doesn’t go as planned.

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

Does your thinking survive without it?