The AI-and-work discourse is almost entirely a subtraction problem: which roles get automated, how many, how fast. Hidden inside it is a mirror image — a specific, nameable set of jobs whose demand rises as AI capability rises: the ones that verify, audit, specify, handle exceptions, and bear accountability. They grow for the same reason the doom-list exists. The more generation AI does, the more of exactly these the system is forced to buy. Naming them is more useful than another ranking of at-risk occupations, because it tells you where to stand instead of where to flee.
The argument rests on one structural fact I've made the case for elsewhere: when generation gets cheap, the binding constraint moves to verification, and verification is human-intensive and trust-laden in a way generation is not. If you accept that the constraint has moved, the employment consequence follows mechanically. Value and demand accumulate at the constraint. So the roles that sit at the verification bottleneck — checking output, defining the problem, owning the failures, signing the work — are the ones the economy needs more of every time a model gets better, not fewer.
Why the demand curve bends the opposite way
Start with the mechanism, because it's the part that makes this a forecast rather than a wish. Cheap generation doesn't leave the amount of checking fixed; it multiplies it. This is Jevons' paradox applied to output: when a competent draft costs a penny, you don't make the same number of drafts for less money, you make a hundred times more of them. The 200-line pull request becomes ten 2,000-line pull requests. The one marketing variant becomes forty. Each still has to be checked, integrated, and owned by someone who is accountable when it's wrong.
So run the arithmetic the automation story skips. Demand for verification is roughly the per-unit cost of checking one artifact multiplied by the number of artifacts. AI drives the volume term up by one or two orders of magnitude while barely touching the per-unit term, because checking is bounded by judgment and contact with reality, not by compute. The product goes up. That is the entire reason a category of work can grow because of automation rather than in spite of it — the thing being automated is the input to the thing you now need vastly more of.
This is not a new shape of argument, and it's worth attributing honestly. David Autor's task-based framing says a job is a bundle of tasks; machines take some, and in doing so they often raise the value of the complementary tasks a human still does. Labor-market polarization — the hollowing of the middle while the ends hold — is the empirical footprint of exactly that process. What's different now is that the complementary task being made more valuable is unusually general. It isn't "operate the more productive loom." It's "verify, specify, and vouch for machine output," and that applies across law, code, medicine, research, and operations at once.
The Kasparov precedent is the cleaner intuition. After losing to Deep Blue, Kasparov didn't conclude humans were obsolete at chess; he proposed "advanced chess," human-plus-machine teams, and for a period the strongest competitive entities were centaurs — a human directing, selecting, and vetting engine output rather than out-calculating it. The human's job wasn't to generate better moves than the machine. It was to choose among and check what the machine proposed. That role didn't shrink as engines got stronger; it changed shape. The verification economy is that centaur pattern escaping the chessboard and becoming a labor market.
The map: six roles the doom-list ignores
Here are the categories I'd bet on, each with the mechanism that makes it grow as AI improves. I'm labeling the whole set a forecast, not a description of an arrived-at world.
| Role | What they do | Why demand rises with AI |
|---|---|---|
| Verifiers / reviewers | Check AI output at scale — the QA of everything | Volume of output to check explodes |
| Auditors | Assess AI systems, decisions, and compliance | More consequential automated decisions need independent scrutiny |
| Spec-writers / problem-definers | Turn fuzzy goals into agent-legible objectives | Cheap execution makes precise specification the bottleneck |
| Exception-handlers | Own the hard cases AI escalates | Automation handles the easy 95%, concentrating the hard 5% |
| Trust-brokers / accountability-holders | The named human who vouches for AI-assisted work | Someone must be liable; a model cannot be |
| Integrators | Wire AI into real workflows and systems | Capability is worthless until it's plumbed into how work actually happens |
Verifiers and reviewers. QA generalized from software to nearly everything. When a team ships 10x more code, contracts, or content, someone has to read it before it becomes liability. The scarce skill is not producing a first draft — the machine does that — it's the trained ability to look at a plausible output and know, quickly, whether it's actually correct and why. That skill gets more valuable as outputs get more fluent and therefore more convincingly wrong.
Auditors. As decisions get delegated to systems — credit, diagnosis, hiring screens, agentic actions — demand for independent parties who can examine those systems and attest to how they behave rises with the stakes. This is where a genuinely new profession is forming: the AI auditor, analogous to the financial auditor, whose product is a credible external judgment that the system does what it claims. Regulation will accelerate this, but the underlying driver is that no organization can absorb automated decision-making at scale without someone whose job is to check the machine.
Spec-writers and problem-definers. When execution is cheap, the expensive and scarce input becomes a precise statement of what to execute. Anyone who has watched an agent confidently build the wrong thing understands this immediately: the model will faithfully optimize a badly-specified objective, and the cost of the ambiguity lands downstream. Writing a spec unambiguous enough for an agent — resolving the contradictions in what a stakeholder actually wants before code gets written — is a distinct, trainable skill whose value rises as the cost of acting on the spec falls.
Exception-handlers. Automation is best at the common case and worst at the tail. As AI absorbs the routine 95% of a workflow, the human residue isn't lighter — it's concentrated into the gnarliest, highest-context, lowest-frequency cases, the ones with no rule to follow. The person who owns the escalation queue for a fleet of agents is doing harder work than before, not easier, because every case that reaches them is one the system already failed on.
Trust-brokers and accountability-holders. A model cannot be a defendant, cannot hold a license, cannot be struck off. Whenever AI-assisted work carries real consequence, the system requires a named human who vouches for it and absorbs the liability — the attending who signs the chart, the engineer who owns the deploy, the partner whose name is on the opinion. This connects to proof-of-personhood and the anxiety behind "dead internet theory": as machine output floods every channel, the ability to point to an accountable human becomes scarce and therefore valuable. Accountability doesn't automate, because its entire function is to be un-automatable.
Integrators. Raw capability sitting in an API is inert. The work of wiring it into a messy real workflow — the data, the permissions, the edge cases, the humans who have to trust it — is where most of the value actually gets captured, and it scales with the number of capabilities there are to integrate. Every model improvement creates more integration work, not less.
The honest part
I won't sell this as salvation; that would be the mirror-image dishonesty of the doom-list. Three caveats, plainly.
First, "demand bends up" is a statement about slope, not level or status. A lot of this work is unglamorous — reviewing logs, chasing exceptions, filing audit trails — and some of it will stay modestly paid even as it becomes load-bearing. The claim is that the curve rises, not that every role on it is prestigious.
Second, the transition is genuinely disruptive and distributes its pain unevenly. Telling a displaced worker that "verification demand is rising" is cold comfort if the growing role requires skills and credentials they don't have and can't quickly get. Aggregate category growth and individual dislocation coexist; both are real.
Third — the strongest counterargument, stated fairly — this window may narrow. As models improve, more verification becomes machine-checkable, and the automatable floor rises under all six roles. The optimistic case for a durable human verification economy leans on domains where checking has no short certificate and where accountability is legally or socially required. That's a large space, but it isn't permanent, and anyone who treats "verifier" as a lifetime moat is making the same static-thinking error as the person who thought "coder" was one. There's a deeper worry from the AI-safety literature too: Bostrom's instrumental convergence suggests sufficiently capable agents pursue subgoals — resource acquisition, resistance to correction — that make supervising them structurally hard, not merely laborious. If verifying the most capable systems becomes something humans genuinely cannot do rather than merely find expensive, the floor doesn't rise, it caves. I take that as a real tail risk on the thesis, not a refutation of its near-term shape.
What to actually build
Treat this as a rebalancing problem, which I've argued is the right way to manage any skill set. Overweight the capabilities that get more valuable as AI improves, because they're rare — most skills get less valuable. The ones that compound:
- Judgment you can defend. The ability to look at a plausible output and say whether it's right and why — the reviewer's core skill, trainable through deliberate reps of predicting, then checking.
- Precise specification. Writing a problem statement clear enough that an agent, or a stranger, could execute it without guessing. This is the spec-writer's edge, and it's practiceable today.
- Reading systems for failure modes. Seeing where a workflow breaks before it breaks — the auditor's and exception-handler's instinct.
- Owning outcomes in your name. Building the track record and credibility that let you be the accountable signer — the scarcest and least automatable asset of all, because it's made of trust.
- Integration fluency. Knowing enough about real workflows, data, and humans to wire capability into something that ships.
None of these is a first draft. Every one is a form of checking, framing, or vouching — the human half of the centaur. The doom-list tells you what to run from. This is the shorter, more useful list: what to run toward, because it grows as the machines do.