index

Kitces’ essay, Why ChatGPT Is No Threat To Real Advisors, makes a common claim: people trust people more than models. He argues that gap keeps humans central even as models get better at drafting and summarizing.

I don’t buy it.

People rarely trust “humans” in the abstract. They trust other people’s judgment. They trust their own experience. They keep a running score of what tends to work. A tool earns trust when it beats the old baseline often enough that you stop fighting it.

People didn’t switch from horses to cars because someone won a debate about transportation. They switched because cars went farther and faster. Reliability came later. Once the advantage was obvious, the culture adapted around it.

Why models feel unreliable

Models feel unreliable when you ask them to do real work with missing inputs and no way to check the output.

If you hand a model a high-stakes task and it has to guess (missing context, missing documents, no access to the system of record), it fills in the gaps. When it does that in fluent language, we call it hallucination. The failure mode is simple: uncertainty gets shipped as certainty.

The fix is boring:

• Give it the real inputs: the documents, the numbers, the constraints.
• Let it use the same tools you use: calculators, databases, APIs, search.
• Require a proof you can verify: citations, intermediate steps, tests, reconciliations.
• Treat “I don’t know” as a valid output. Route edge cases to a human and learn from them.

In that setup, trust comes from the loop: do the work, check it, fix it, repeat.

Coding is the clearest case

Software is where this is easiest to see because the checks are built in.

Over the last nine months, I’ve watched the change happen in real time. I do not write code anymore. I describe what I want, the model takes a pass, I run it, and I look at what broke.

The line of sight is obvious: less human in the loop, then almost none. Some of our industries best engineers agree (Boris Cherny).

Models still make mistakes, but in code those mistakes are loud. The compiler complains. Tests fail. Types don’t line up. The UI looks wrong.

That feedback loop makes delegation easy. You find out fast when it’s wrong, and you fix it.

The gains came from more expert feedback, better training loops, better tools, and better evaluation. In many coding tasks, the model is a stronger baseline than the average human starting from scratch. Once you see that, you hand it more.

This spreads

Every industry has work that is hard to measure in the moment and tied to human context: relationship, taste, ethics, accountability.

But every industry also has a huge amount of work that is concrete and checkable:

• gather inputs
• apply constraints
• run standard analyses
• draft the artifact
• sanity-check edge cases
• document decisions
• follow up

As soon as that work is set up so the model can see the real inputs and the output can be checked, you get fewer surprises. The hesitation drops because the wins stack up.

Trust is not the same thing as price

Even if a model becomes better than a human at a chunk of knowledge work, that doesn’t mean customers will pay the same price for it.

Some businesses will still pay for a human because they’re buying accountability and emotional throughput: someone who can absorb ambiguity, manage anxiety, persuade stakeholders, and own the outcome when things go wrong.

But in plenty of domains, what used to be expensive expertise will get partially commoditized. If a model can do most of the analysis, the market won’t keep paying “expert rates” for the part that looks like running the playbook. The premium shifts to what’s scarce: judgment about goals and trade-offs, oversight, and responsibility for decisions.

Objections that matter

“It still makes mistakes.” Yes. So do people. The comparison is whether the loop beats the baseline on accuracy and how quickly errors get caught. When stakes are high, you add guardrails: audits, review, constrained tooling, explicit accountability.

“This will create slop.” Also yes. Cheaper production increases volume and drags down the average. The scarce skill becomes constraints and review: specify what you want, detect when it’s wrong, decide what ships.

You trust what keeps being right. You trust it faster when you can catch it when it isn’t.