Human–AI Division of Labor

Every AI-augmented workflow embeds a decision someone made — deliberately or by default — about which work goes to the machine and which stays human. Made well, the division compounds: humans spend their scarce judgment where it matters while agents grind through the verifiable middle. Made badly, it produces the two signature failures of the era: humans rubber-stamping machine output they cannot actually evaluate, and expensive experts hand-polishing work a model would have done identically in seconds.

This page gives you a framework for making that decision on purpose.

The four questions

For any candidate task, ask in order:

1. Can I verify the output at reasonable cost? This is the gating question, inherited directly from Verification Thinking. Delegation transfers generation, never responsibility — so if you cannot tell good output from bad, or telling costs more than doing, delegation is an illusion. A task you cannot check is a task you cannot delegate, whatever the demo suggests.

2. What is the cost of an undetected error? Not the cost of an error — the cost of an error that slips past your verification. Drafting an internal summary: an escaped error costs a moment of confusion. Generating dosage tables, security rules, contract clauses: an escaped error costs something you may not be able to buy back. High blast radius does not forbid AI involvement; it forbids AI involvement without a human owning the output line by line.

3. Is the task specification-complete, or does it need judgment the spec cannot hold? Some tasks can be fully stated: transform this format, implement this documented function, translate this text. Others hinge on context no prompt captures — organizational politics, taste, a client’s unspoken priorities, ethical weighing, the decision of what to want. Models execute specifications; they do not carry accountability, relationships, or values. If writing a complete spec is impossible — not just tedious — the judgment core of the task is human, though its scaffolding may not be.

4. Does doing this task build capability I will need later? The apprenticeship question. Verification skill is built by generation experience: the reviewer who can smell a subtle concurrency bug is the one who wrote and broke concurrent code for years. Delegating all routine work to agents is eating your seed corn — juniors who never do the reps become seniors who cannot check the machine. Deliberately keep a fraction of delegable work human, as training load.

The decision framework

    flowchart TD
    T[Candidate task] --> V{Can I verify output cheaply}
    V -->|No| H1[Keep human or invest in making it verifiable first]
    V -->|Yes| E{Undetected error cost high}
    E -->|Yes| R[Delegate drafts only with full human review of every line]
    E -->|No| S{Fully specifiable}
    S -->|No| P[Split it - human owns judgment core - agent does scaffolding]
    S -->|Yes| L{Needed for skill building}
    L -->|Yes| K[Keep some reps human - delegate the rest]
    L -->|No| D[Delegate fully with spot checks]

Note what the flowchart optimizes: nothing reaches full delegation without passing verifiability, blast radius, specifiability, and learning-value checks. Most real tasks land in the middle branches — partial delegation — which is why the interesting skill is not choosing whether to use AI but drawing the seam.

Drawing the seam: task splitting in practice

The four questions rarely give one answer for a whole task, because whole tasks are bundles. The move — pure decomposition — is to split the bundle at the point where the answers change:

Code review: agent flags style issues, likely bugs, and missing tests (verifiable, low blast radius); human judges architecture fit and whether the change should exist at all (unspecifiable context).
Incident response: agent collates logs, timelines, and similar past incidents; human decides mitigation under uncertainty and communicates with stakeholders (accountability cannot be delegated).
Content: agent produces variants and adapts formats; human owns the claims, the voice, and anything with a signature under it.
Research: agent does breadth — surveys, summaries, citation gathering (each item spot-checkable); human does depth — deciding which thread matters and what the findings mean for this decision.

The pattern across all four: agents get the verifiable middle; humans keep the two ends — deciding what to want (formulation) and deciding whether it is right (evaluation). That is the CT loop from Foundations with the generation box outsourced.

Beware automation creep: seams drawn carefully in January are gone by June, because each individually reasonable “the agent handles that now” step erodes the human’s ability to perform the next verification. Schedule periodic reviews of the division itself — the framework is a loop, not a one-time sort, both because models improve and because your unexercised skills decay.

Delegation is a skill with reps

Expect your first divisions to be wrong in both directions: you will under-delegate tasks the model handles flawlessly and over-delegate tasks whose failure modes you had not met yet. Treat each miss as calibration data — keep notes on what came back wrong and how you caught it. Within months you develop the same fingertip feel a good tech lead has for what to hand a new team member: not a rule book, but a trained instinct built on exactly these four questions.

Which underlying skills appreciate as this practice spreads — and which quietly commoditize — is the subject of Enduring Skills.

References

Verification Thinking Model Thinking