An AI feature that takes ten seconds to generate an answer and two minutes to check whether that answer is right hasn't saved anyone a thing. It's just moved the effort somewhere worse.
What happened
Two pieces this week tackle the same question from different angles: when does it actually make sense to put AI into a product? One proposes a four-question audit for product teams, built around a deceptively simple idea — weigh the cost of verifying AI output against the value of automating the task in the first place. The other challenges the industry's reflex to put AI in everything, pointing to smart toothbrushes and mood-reading robots as solutions nobody needed.
Both arrive at the same uncomfortable point. The question isn't "can we add AI?" It's "does this feature genuinely improve the experience, or has it just invented a new kind of work?"
The verification tax
Here's what I think we're massively underestimating as designers: the cost of checking.
When AI writes your email draft, you read it, adjust the tone, fix a factual slip, then hit send. That's not saving time — that's editing someone else's homework. When AI summarises a long document, you still skim the original because you're not confident about what got dropped. When AI suggests a layout, you evaluate it, nudge it, and probably start over. The doing has been swapped for checking.
And checking is arguably harder. When you do something from scratch, you build understanding as you go — you're in control of the reasoning. When you check AI output, you have to reverse-engineer the reasoning, spot what's off, and decide whether to trust the bits you can't easily verify. That's a different cognitive load entirely, and it's exhausting in a way that doing the task yourself often isn't.
I'd call this the verification tax. And almost nobody is designing for it.
When the tax gets expensive
The verification tax bites hardest when three things are true at once.
The output looks plausible. AI is brilliant at producing things that seem right — fluent text, reasonable layouts, sensible-looking code. The more polished it appears, the harder errors are to spot. Plausibility is the enemy of accuracy here.
The stakes aren't trivial. Get a playlist recommendation wrong and nobody cares. Get a medical summary wrong, or a contract clause, or a user-facing notification — that's a different conversation. Higher stakes means more checking, which means less time saved, which means the feature starts working against itself.
The user didn't ask for help. The worst offenders are AI features that insert themselves uninvited. Auto-suggestions that break your flow. Summaries you didn't request. "Smart" rewrites that assume they know what you meant. Each one demands attention and verification even when you dismiss it.
When all three apply, the AI feature isn't helping. It's imposing a cognitive toll on every single interaction.
So what do we actually design for?
If you're building an AI-powered feature, generating the output is the easy bit. The real design challenge is making verification fast, transparent, and low-effort. That's where the craft lives.
It means showing your working. Let users see why the AI made a choice, not just what it chose. It means designing for rejection — making it effortless to say "no, not this" without losing progress or context. And it means being honest about confidence. If the model isn't sure, the interface should say so. A confident-looking wrong answer is far more dangerous than a visibly uncertain one.
Before you ship, walk through the actual experience of checking the output. Time it. Compare it honestly to doing the task from scratch. If verification takes as long as manual effort — or longer — you haven't built a useful feature. You've built a chore with extra steps.
Takeaway
Next time you're designing an AI feature, don't just prototype the happy path where everything works perfectly. Prototype the checking. Sit with a user and watch them verify the output. Time how long it takes. Notice where they hesitate, where they second-guess, where they give up and start from scratch.
That gap between "here's what AI made" and "I trust this enough to use it" — that's where your design problem actually is. And if you can't close it, the feature isn't ready.