Decomposing Human Capability for AI Automation
Given any task, run this classification on every subtask before writing a single prompt or workflow:
For each subtask S in the decomposed task:
1. Can correctness of S's output be checked by a fixed, restatable rule
(regex, schema, numeric threshold, unit test, lookup table)?
YES -> candidate for AI-autonomous execution
NO -> go to 2
2. Does S require weighing incommensurable values, assuming legal/reputational
risk, or exercising judgment that varies legitimately by context/culture/politics?
YES -> human actuation point (do not automate the decision, only the drafting)
NO -> go to 3
3. Is S high-volume, low-stakes-per-instance, and reversible if wrong?
YES -> AI-autonomous with logged output, spot-audited (sampling gate)
NO -> AI-executed, output routed through deterministic checkpoint before
proceeding (schema validation, cross-reference check, confidence
threshold, or second-model verification)
This is the core decision tree. Everything below is the process for building the subtask list this tree operates on, and the scale-level analysis of why teams get this wrong.
RPA / workflow automation maps observed human actions (clicks, form fields, file moves) rather than the decision logic behind them. It fails when:
- The human varies their action based on context not visible in the interface (e.g., a claims adjuster approves similar-looking claims differently based on unlogged phone conversation tone — documented failure mode in insurance RPA deployments, see Willcocks & Lacity's work on RPA at Xchanging/Telefónica, Service Automation: Robots and the Future of Work, 2016 — RPA bots require "stable, rules-based, high-volume" processes and degrade sharply outside that envelope).
- Tacit knowledge (Polanyi, The Tacit Dimension, 1966) — the "we know more than we can tell" problem — means the human executing the task cannot fully articulate the rule they're following, so there is no rule to encode. RPA has no mechanism to extract a rule that was never explicit.
Naive prompt-chaining treats each step as independently promptable and assumes errors don't compound. This fails because:
- Without a deterministic checkpoint between steps, errors compound multiplicatively. This is the same failure mode documented in chain-of-thought reliability studies — e.g., Turpin et al., "Language Models Don't Always Say What They Think" (NeurIPS 2023), showing stated reasoning doesn't reliably reflect the actual decision process, so chaining on unverified intermediate output propagates hidden errors.
- It has no principled place to put a human. Humans get bolted onto the front (prompt writing) or back (final review of a black-box output), which is exactly the "human as approval rubber stamp" pattern criticized in human-in-the-loop ML literature (e.g., Green & Chen, "Disparate Interactions," FAT* 2019, on how end-of-pipeline human review fails to catch upstream errors because reviewers lack visibility into intermediate reasoning).
Both approaches share the core defect: they treat the task as a black box with an input and output, rather than decomposing the internal logic of the task into artifacts, subtasks, and dependencies. Neither has a systematic method for identifying which sub-elements are tacit/judgment-based versus rule-based — they discover this only through production failures.
Progress:
- Step 1: Artifact-trace the task
- Step 2: Decompose into subtask graph with dependencies
- Step 3: Classify each node (autonomous / gated / human-actuation)
- Step 4: Define the deterministic gate for each gated node
- Step 5: Build the scaffold (routing logic between nodes)
- Step 6: Pilot on historical cases with known-correct outcomes
- Step 7: Instrument for drift (re-audit gate thresholds periodically)
Step 1 — Artifact-Trace the Task
Interview or observe the expert performing the task 3-5 times, capturing every artifact produced or consumed (documents, decisions, emails, spreadsheet cells, verbal judgments) and every point where they hesitate, second-guess, or say "it depends." Those hesitation points are your candidate human-actuation nodes — they are where tacit judgment lives.
- Logic gate: none yet — this step is observational.
- Human actuation: the expert must narrate their own hesitations; this cannot be inferred from output alone.
- AI payload: AI can transcribe, cluster, and pattern-match across multiple sessions to flag recurring hesitation points (candidate judgment nodes) versus one-off noise.
- Adversarial counter: "This is just process mapping with extra steps — traditional BPM does artifact tracing too." Rebuttal: BPM artifact tracing stops at documenting the sequence; it does not specifically instrument for hesitation/uncertainty as a signal, and typically discards the "it depends" moments as noise rather than treating them as the primary data of interest.
Step 2 — Decompose into Subtask Graph
Break the traced process into a DAG of subtasks with explicit input/output artifacts per node. Each edge represents a dependency (subtask B cannot start until artifact from A exists).
- Logic gate: a subtask is a valid node only if its output artifact can be named and its input artifacts enumerated. If you cannot name the artifact, you have not decomposed far enough — recurse.
- Human actuation: none — this is structural decomposition, checkable by the expert for completeness.
- AI payload: AI can propose the DAG from the Step 1 transcript and artifact list, but the expert must validate it — this is a checkpoint, not autonomous execution.
- Adversarial counter: "DAG decomposition is standard flowcharting (BPMN); nothing new." Rebuttal: correct — the novelty isn't the DAG, it's that every node is required to carry a classification tag (Step 3) before it's allowed into an execution pipeline, which BPMN diagrams don't enforce.
Step 3 — Classify Each Node
Apply the Quick Start decision tree above to every node.
- Logic gate: the three-question tree is the gate itself — deterministic by construction (each question has a yes/no answer verifiable against a rule, not opinion). If the classifier can't answer question 1 or 2 with evidence, default to human-actuation (fail closed, not open).
- Human actuation: the expert must confirm classification for any node touching legal, safety, or irreversible-consequence artifacts — AI does not self-classify these.
- AI payload: AI can pre-classify low-stakes/high-volume nodes and draft the checkpoint criteria for gated nodes (see Step 4).
- Adversarial counter: "This classification will drift as models improve — capability boundaries aren't stable, so this taxonomy expires." Rebuttal: correct and explicit — this is why Step 7 (drift instrumentation) exists. The methodology assumes reclassification is periodic, not one-time. Cite: Steiner et al. on "capability elicitation" — model capability boundaries are empirically measured, not assumed (see METR's task-based evaluations of AI agent capability, ongoing as of 2024, at metr.org).
Step 4 — Define the Deterministic Gate
For every "AI-executed-but-gated" node, write the actual check: schema validation (JSON schema, regex), cross-reference against ground truth (database lookup, second source), confidence threshold on model output logprobs, or ensemble disagreement check (two models must agree within tolerance).
- Logic gate: this step produces logic gates — it has no gate itself except "is the check machine-executable without a human reading the output?" If not, it's not a gate, it's another human-actuation point mislabeled.
- Human actuation: setting the threshold (what confidence level, what disagreement tolerance) is a human judgment call informed by the cost-of-error asymmetry for that specific task.
- AI payload: AI can draft candidate schemas/checks from examples of correct vs. incorrect past outputs.
- Adversarial counter: "Confidence scores from LLMs are not reliable probability estimates — Kadavath et al. ('Language Models (Mostly) Know What They Know,' Anthropic, 2022) and later work show calibration varies by task and model." Rebuttal: this is exactly why the gate should never rely on self-reported confidence alone — use structural checks (schema, cross-reference, ensemble) as the primary gate and treat model confidence as a secondary, weaker signal, per the same paper's finding that calibration is better for verifiable/objective questions than subjective ones.
Step 5 — Build the Scaffold
Wire the nodes together with routing logic: autonomous nodes execute and pass output forward; gated nodes execute, run the check, and either pass forward or route to a human queue on failure; human-actuation nodes pause the pipeline and present the artifact bundle needed for the human to decide.
- Logic gate: routing is deterministic (if-check-passes-then-forward, else-queue).
- Human actuation: the human decides at actuation nodes with full artifact context assembled by the prior AI nodes — this is the "human decides, AI prepares" pattern.
- AI payload: AI assembles the decision packet (relevant artifacts, prior similar cases, gate failure reason) so the human's actuation is fast and informed, not a cold start.
- Adversarial counter: "This is just human-in-the-loop ML with extra terminology." Rebuttal: standard HITL puts the human at the end reviewing a finished output; this puts humans at specifically identified internal nodes, mid-pipeline, only where Step 3 classified judgment as required — reducing human load to true judgment calls rather than blanket review.
Step 6 — Pilot on Historical Cases
Run the pipeline against N historical cases where the correct outcome is already known (closed cases, past decisions, graded assignments). Measure: (a) autonomous node accuracy against ground truth, (b) gate false-pass rate (bad output that slipped through), (c) human-actuation node time cost.
- Logic gate: false-pass rate above a pre-committed threshold (set by the human in Step 4) blocks deployment — this is a hard stop, not a judgment call at this stage.
- Human actuation: setting the acceptable false-pass threshold before seeing results (to avoid post-hoc rationalization).
- AI payload: none — this is measurement, not generation.
- Adversarial counter: "Historical cases don't cover distribution shift / novel cases the pipeline will meet in production." Rebuttal: true and unresolved by this step alone — this is exactly why Step 7 exists as a permanent, not one-time, part of the methodology.
Step 7 — Instrument for Drift
Log every gate pass/fail and every human-actuation decision in production. Periodically (defined cadence, e.g., monthly) re-audit: are gate thresholds still appropriate, are new failure patterns emerging, has model capability shifted the Step 3 classification for any node.
- Logic gate: statistical process control — if gate failure rate shifts beyond a control limit (e.g., 2 standard deviations from pilot baseline), automatic escalation