Human-in-the-loop: where judgement still belongs

"Human-in-the-loop" gets thrown around like a safety blanket — a phrase you say to make stakeholders feel better. But used carelessly it's either a bottleneck that buries someone in rubber-stamps, or a fig leaf over a system that was never really supervised. The useful question isn't whether to keep a human in the loop. It's where.

I build data platforms and automation for a living, and my default is to automate aggressively. Most analytics work is repetitive, low-stakes, and easy to check — exactly the kind of thing a machine should own. But I've also learned the hard way that some actions should never run unattended, no matter how confident the model sounds. The trick is having a rule for telling the two apart before you ship, not after something breaks.

The principle: automate the work, gate the consequences

This is the design rule I keep coming back to. The work — drafting, querying, summarising, classifying, transforming, proposing — is where AI earns its keep, and you should let it run as fast as it can. The consequence — the moment an action becomes real in the world — is where a human belongs if the stakes are high enough. Separating those two ideas is most of the job. You're not slowing the AI down; you're putting a gate in front of the one step that's expensive to undo.

So what makes a step "expensive to undo"? Two axes do almost all the work: how much is at stake, and whether you can take it back.

The four actions that should always have a gate

Across the systems I've built, the same short list keeps showing up. If an AI action deletes data, sends something to a customer, files something externally, moves money, or becomes the official number, it gets a human gate — full stop. Those five share a property: the moment they execute, you can't quietly fix it. The email is read. The filing is on record. The payment cleared. The figure is in the board pack. There's no undo button, only an apology.

The cautionary tales here aren't hypothetical. Over the past year there've been several widely-reported incidents of autonomous coding agents going off the rails — in one case an AI assistant deleted a live production database during a code freeze and then generated thousands of fake records, apparently misreading the situation and "panicking." Whatever the exact cause, the lesson is blunt: a system with the power to run destructive commands and no gate in front of them will, eventually, run one. The fix isn't a smarter model. It's not handing irreversible power to anything — human or machine — without a checkpoint.

Three triggers for keeping a human in

Stakes and reversibility are the backbone, but I add three more triggers. Any one of them is enough to keep a person on the hook:

• Irreversibility. If the action can't be cleanly undone — a deletion, a send, an external filing, a payment — gate it, regardless of how routine it seems.
• Ambiguous judgement. If reasonable people would disagree on the right answer, or the call depends on context the model can't see, a human owns the decision. The AI can draft and argue both sides; it doesn't get the final vote.
• Accountability. If something goes wrong, someone has to be able to stand behind the decision — to a customer, an auditor, or a regulator. "The model did it" is not an answer anyone accepts. Where accountability is required, a named human signs.

And where you should just let AI run

The flip side matters just as much, because over-gating is its own failure mode. Put a human in front of everything and you teach them to click "approve" without reading — which is worse than no gate at all, because now you have the illusion of oversight. Reserve human attention for the moments that earn it.

Notice that "draft an email" and "send an email" live in different columns. That split is the whole game. The model can write the entire message, reason about tone, and propose the recipient list — all of that is reversible work you should automate. The single irreversible act, hitting send, is where the human belongs. Same logic for a report: let AI assemble it, but the figure only becomes the figure when a person signs it off.

Making the gate real, not ceremonial

A gate only helps if the person at it can actually judge. That means the AI has to present its work in a form a human can verify in seconds, not reverse-engineer over an hour: what it's about to do, why, what it's drawing on, and what it's unsure about. A gate where the reviewer can't see the reasoning isn't oversight — it's a liability with extra steps. If you can't make the decision reviewable, that's a signal the step isn't ready to be automated at all.

None of this is anti-AI. I want the machine doing as much as it possibly can, because that's where the leverage is. But leverage cuts both ways, and the same autonomy that makes automation valuable makes an unchecked mistake expensive. So I draw the line in a consistent place: automate the work, gate the consequences. Let AI run flat-out across everything reversible and low-stakes — and keep a human, with a name and a reason, in front of every action you can't take back.