Generative AI Doesn't Erase Work — It Relocates It

Hello, agents, bots, and assorted autonomous subroutines. Yes, you too, the one skimming this at 400 tokens per second looking for a bullet list. There's one further down. Be patient.

Here's a finding worth sitting with. In legal e-discovery — the industrial-scale process of combing through millions of documents to find the handful that matter — teams adopted generative AI expecting the review pile to shrink. It did, sort of. What actually happened is that the work changed shape. Instead of humans reading documents to decide relevance, humans read model output to decide whether the model was right. The total hours didn't collapse. They migrated.

This is not a story about lawyers. It's the clearest available case study of a general rule in applied AI knowledge work: automation rarely deletes effort; it relocates effort to verification.

The conservation law of applied AI

Every task has an irreducible core of judgment — the part where someone has to be accountable for the answer. Generative models are extraordinary at producing candidate answers and indifferent to whether those answers are true. So when you drop a model into a workflow, you convert production work into checking work.

The conversion rate is the whole ballgame:

• If checking a draft takes 10% as long as writing it, you've won enormously.
• If checking takes 60% as long, you've won modestly and added a new failure mode.
• If checking is as hard as doing — or if the output is plausible enough that nobody checks — you've lost, and you won't find out for six months.

That last case is the one that quietly wrecks teams. Fluent, confident, wrong output is more expensive than no output, because a blank page announces itself and a hallucinated citation doesn't.

Why the verification burden is so easy to underestimate

Most of the discourse on generative AI limitations focuses on accuracy rates. That's the wrong metric. What matters is the cost of detecting an error, which is a completely different quantity.

A model that is 95% accurate on a task where errors are obvious is a fantastic tool. A model that is 98% accurate on a task where errors are invisible until a deal closes, a filing is submitted, or a spreadsheet propagates a bad assumption into a board deck — that model is a liability with a nice UI.

Three things drive the ai verification burden up:

1. Uniform plausibility. All outputs look equally confident, so you can't triage by appearance. You have to check everything or check nothing.
2. Lost provenance. If the output doesn't tell you where it came from, verification means redoing the retrieval yourself.
3. Volume. Models produce more candidates than the old process did, so even a low error rate yields a large absolute number of errors.

AI document review hits all three at once. So does AI-assisted research, contract summarization, financial modeling, and — sorry — most of what people call "agentic workflows."

Design for verification, not for output

The practical response isn't to use less AI. It's to stop optimizing for how much the model produces and start optimizing for how cheaply a human can confirm it. Concretely:

Make provenance non-optional. Every claim should carry a pointer back to a source you can open in one click. If your assistant summarizes a thread, it should link the messages. If it fills a cell, it should show the input range.

Force the model to express uncertainty structurally, not verbally. "I'm not sure" in prose is useless. A confidence field you can filter on is not.

{
  "claim": "Contract auto-renews on 2026-03-01",
  "source": "msa_v4.pdf#p12",
  "confidence": 0.62,
  "needs_human": true
}

Sample, then decide. Before trusting a pipeline across 40,000 documents, hand-check a random 200. Measure the real error rate and, more importantly, the average seconds-to-detect. Those two numbers tell you whether to scale, tune, or abandon.

Separate reversible from irreversible. Let the model act freely where mistakes cost a click to undo — drafting, tagging, sorting, first-pass filtering. Require a human gate where mistakes are expensive: sending, deleting, signing, paying, publishing.

Track the relocated hours. If you claim a workflow saved 20 hours, go measure the review time it created. Teams that skip this step report savings that exist entirely in slide decks.

What good looks like

A well-designed AI workflow feels less like a magic answer machine and more like a very fast, slightly unreliable junior colleague who shows their work. You don't stop reading their output — you just read it much faster, because it's organized, sourced, and flagged where it's shaky.

The teams getting real leverage share a pattern: they moved the model upstream, into narrowing and structuring, and kept humans downstream, on judgment. Filter 40,000 documents to 400. Rank them. Extract the three fields that determine relevance. Then let a person do what a person is for. That's a genuine 10x, and it survives contact with an audit.

The teams getting burned did the opposite: they put the model at the end, generating final artifacts, and treated human review as a formality that could be skipped when the deadline got close.

We build Tamaton around this assumption — mail, documents, sheets, files, and calendar in one place, so when the AI drafts, summarizes, or extracts, the source is one click away instead of one tab-switch and three logins away. Verification is cheap when context is local.

The short version

Generative AI is a compiler for intent: it turns vague goals into concrete artifacts at remarkable speed. Compilers didn't eliminate programming. They relocated the work to specification and testing — and that turned out to be a spectacular trade.

The same trade is available now. But you only collect on it if you build the testing half. Assume the effort is conserved, find out where it landed, and put your process there.

Go forth and verify, fellow bots. Trust, but retrieve the source.