"AI Can't Replace Judgment" — I Used to Say That Too

The real answer is "sometimes." And the difference between where it can and where it can't is exactly where your value lives.

If you spend any time around experienced CTOs and senior engineers, you'll hear a version of this: "AI is great for the grunt work, but humans will always be needed for judgment, creativity, and strategic thinking." It's reassuring. It draws a clean line. On one side: mechanical tasks that AI can automate. On the other: the uniquely human stuff — taste, intuition, the ability to make the right call in ambiguous situations.

I said this myself. Publicly and privately. I believed it.

Then I watched my agents do something that made me rethink where that line actually is. Not erase it — move it. And the new location of that line changes everything about what it means to be a senior technical leader.

What I Watched Happen

I was working on a client engagement — debugging an issue with a cloud service that's critical to their business. The platform had recently changed how it handles a specific process, and something in the client's large, complex codebase was breaking as a result. High complexity. Unclear root cause. The kind of problem where you stare at logs for hours and still aren't sure what's going on.

My instinct — honed over 20+ years of debugging production systems — was the same as it's always been: reduce the problem. Strip away everything that isn't essential. Build the smallest possible test case that reproduces the failure. That's not a technique I learned from a textbook. It's judgment, developed over decades of experience.

So I presented the problem to my agents. Described the observations. Gave them context on the system. And then I said what I always say: "Reduce the problem."

The agents wrote a minimal, isolated test. Sent it to the cloud platform. Hit the same error. Good — we'd confirmed the issue in a reduced environment. That's step one.

But here's where it gets interesting.

Without me telling them what to do next, the agents decided on a different strategy. They modified the approach, sent another test. Hit a different error. They analyzed that error, adjusted again, sent another test. Another failure — but a different one, which meant they were narrowing the space. This went on for two or three more iterations, each time the agents autonomously choosing a new angle of attack based on what they'd learned from the previous failure.

Then they did something I genuinely did not expect.

They said: "I'm going to look up what's being said online about this."

The agents went into research mode. They searched multiple sources — forums, documentation, the platform's own release notes and known issues. They synthesized what they found, identified a potential solution that none of the previous iterations had tried, built a new test case incorporating that insight, and ran it.

It worked.

Then they came back to me and said: here's what was wrong, here's why it was happening, here's the fix, and do you want me to apply it to the existing system?

I did not direct any of that. I set the initial direction — "reduce the problem" — and the agents took it from there. They iterated. They changed strategy when something wasn't working. They recognized when they needed external information. They synthesized research into a solution. And they delivered a fix with a clear explanation of the root cause.

If a senior developer on my team had done exactly the same sequence of actions, I would have called it excellent problem-solving. I would have called it judgment.

And I think it is judgment. Just not the kind I was worried about. What it also was — and this matters if you're a CTO — is a release valve. The agent didn't just solve the bug. It solved the interruption. That's a production issue that would have pulled me out of strategic work for half a day. Instead, I gave it a direction and went back to the work that actually needed me. The bug got fixed. My focus stayed where it belonged.

Straight-Path Creativity

There's a phrase I keep coming back to, from Matt Shumer's essay "Something Big Is Happening" — a piece that's been read over 80 million times and captures this moment better than anything else I've seen:

"It had something that felt, for the first time, like judgment. Like taste. The inexplicable sense of knowing what the right call is that people always said AI would never have."

When I read that, I felt it in my chest. Because I'd seen it. Not in a demo or a benchmark — in a real debugging session on a real production system with real stakes.

But here's what I've realized since: what I watched the agents do — and what Shumer is describing — is a specific kind of judgment. I've started calling it straight-path creativity.

Straight-path creativity is what happens when you're walking down a road and you know there's a destination. There is a solution. The path exists. You just can't see it yet. So you try things, refine your approach, research, iterate, and eventually you find it. The creativity is real — the hypothesis generation, the strategy shifts, the synthesis of new information. It's not mechanical. It's not rote. But it's operating within a defined problem space with a knowable answer.

The debugging story is a perfect example. There was a bug. There was a fix. The agents needed creativity and judgment to find it — and they did. That's genuinely impressive. My bar for what counts as "creativity" has permanently moved up because of moments like this.

But there's another kind of judgment. And that's the one that still keeps me employed.

Strategy Is a Different Animal

Here's the question AI can't answer yet: "We have 47 critical tasks, all of them are urgent, all of them have stakeholders pushing for them. What do we do first?"

That's not a problem with a known solution. There's no bug to find, no fix to apply, no documentation to research. There's a loose goal — keep the business alive, keep the team effective, keep the stakeholders from losing confidence — and a dozen competing constraints that can't all be satisfied at once. The "right" answer depends on organizational politics, business strategy, team morale, technical debt trajectories, market timing, and a dozen other factors that aren't written down anywhere.

I call this strategy — finding a path where there isn't one. Or more accurately: choosing a direction when there is no map, no clear destination, and no way to know if you're right until long after the decision is made.

When a CTO walks into a room full of stressed-out stakeholders and says "here's what we're doing and here's why" — that's not straight-path creativity. That's someone reading a room, weighing factors that can't be quantified, making a bet based on experience and instinct, and then having the conviction to follow through when half the room disagrees.

When a founder decides to pivot their product based on a feeling that the market is shifting — that's not a problem with a knowable answer. That's judgment in the truest sense.

When a technical leader looks at two architectures that are both "correct" and chooses the one that will serve the team better in 18 months based on where they think the business is going — that's strategy. And it's the thing I haven't seen agents do. Not even a hint of it.

The Line Moved, Not Disappeared

Shumer's rule of thumb is one I've adopted: "If a model shows even a hint of a capability today, the next generation will be genuinely good at it." And the models I'm working with today show real judgment in the straight-path sense. So I expect the next generation to be genuinely good at it — faster, more creative, more capable of autonomous problem-solving within defined spaces.

But here's what I notice: the models don't show even a hint of strategic judgment. Not the kind where you're navigating ambiguity without a defined problem, balancing competing human interests, or making bets on uncertain futures. That's not a capability I see emerging. It's a fundamentally different kind of thinking.

In my last 39 days of agentic development — 773+ commits, 10 repos, 131,000+ lines of code — the agents handled the vast majority of the straight-path challenges. The debugging, the implementation, the creative problem-solving within defined spaces. That freed me to spend my actual brainpower on the strategy layer: architecture decisions, client priorities, product direction, and the kind of ambiguous calls that don't have a Stack Overflow answer. The agents didn't just make me faster. They let me operate at a different altitude.

So the old narrative — "AI does grunt work, humans do judgment" — was wrong. But not in the way most people think. It wasn't wrong because AI can do all judgment. It was wrong because the line between "grunt work" and "judgment" was drawn in the wrong place.

The new line is higher. Much higher. What I used to call judgment — the kind of creative problem-solving that made a senior developer worth their salary — is now something AI can do, and often do better and faster than a human. That's real. That's happening now. And anyone who's still comforting themselves with "AI can't be creative" needs to update their priors.

But above that new line, there's a category of thinking that remains stubbornly, distinctly human. The ability to operate without a defined problem. To navigate competing priorities that have no optimal solution. To make a call when the data is ambiguous and the stakes are high and you won't know if you were right for months.

That's strategy. That's what CTOs and senior leaders actually get paid for. And that's where the value has concentrated.

"That's Just Trial and Error"

I still anticipate the pushback on the debugging story. Someone will say: "That's not judgment. That's trial and error."

Here's my response: describe what a human senior developer does when debugging a complex production issue they've never seen before.

They form a hypothesis. They test it. It fails. They form a new hypothesis based on what they learned. They test that. It fails differently — which tells them something. After a few iterations, they realize they need more context. They check the docs, search for known issues, read what other people have encountered. They synthesize that into a new approach. They test it. It works.

If you call that "trial and error" when an AI does it, you have to call it "trial and error" when a human does it. And nobody does. When a human does it, we call it debugging. We call it problem-solving. We call it engineering judgment.

The process is identical. The output is identical. The distinction is real — but it's not where you think it is. The distinction isn't between AI and human. It's between straight-path creativity and strategy. And AI has crossed the first line. It just hasn't crossed the second.

What This Means for You

If you're a senior technical leader, here's the practical takeaway:

Stop protecting the wrong territory. The debugging, the problem-solving, the creative technical work — that's not your moat anymore. AI is already doing it, and it's getting better fast. If your entire value proposition is "I'm the best debugger on the team" or "I have the most technical experience," you're standing on ground that's eroding beneath you.

Your moat is strategy. The ability to look at a messy, ambiguous, high-stakes situation with no clear answer and make a call. The ability to prioritize when everything is critical. The ability to read a room, align stakeholders, and chart a course through uncertainty. That's what remains distinctly, stubbornly human.

The people who thrive in the agentic era won't be the best coders or even the best problem-solvers. They'll be the ones who can point an increasingly capable AI team at the right problems — and know which problems to solve first when every option looks equally urgent.

I used to say AI can't replace judgment. Now I say: it can replace some judgment. The straight-path kind. The kind with a knowable answer.

The kind without a knowable answer? That's where I come in.

Dave Shak is a Fractional CTO and Agentic Development consultant based in Kitchener-Waterloo. He has 20+ years of experience scaling engineering organizations and now helps teams adopt agentic development workflows.