What to Hand an AI and What to Keep: It Is Not About Difficulty
The advice about what to delegate to an AI almost always sorts work by how hard or how tedious it is. Hand over the boring stuff, keep the thinking.
That axis is wrong, and sorting by it is how people end up handing over the contract summary and keeping the variable rename.
Ten jobs, one at a time
Ten jobs. Doing all of them yourself takes 403.0 minutes. Handing every one to an AI and checking what comes back takes 350.2 — a saving of barely 52.7 minutes, which is why delegate everything feels so disappointing in practice. Choosing task by task takes 288.2. Nearly all of the win is in which jobs you hand over.
The 6 worth delegating — rename 200 variables, find the bug behind a failing test, convert a CSV to JSON, write a regex for this format, unit tests for a pure function, reply to a routine email — have nothing in common except this: something other than you can check the answer, in a few minutes. The 4 to keep — summarise a 40-page contract, cite sources for a claim, pick between three vendors, translate into a language you cannot read — are the ones where the only way to verify the answer is to do the work.
Handing all ten over and reading none of the answers costs 1078.0 minutes: 675.0 worse than doing every one of them by hand. Unchecked output is not a saving, it is a loan.
Ten jobs, one at a time. Beat 403.0 minutes — what the day costs if you do all of it yourself. The clock counts what each choice costs on average, because you never know in advance whether the answer that comes back is right.
- Job
- 1 of 10
- Minutes spent
- 0.0
- All of it yourself
- 403.0
- Best possible
- 288.2
This decision, as text
On the desk
Clock
For comparison
The times and error rates are stated assumptions, not measurements of any particular model or person. The ordering they produce is what matters, and it holds for any numbers where checking is much cheaper than doing on some tasks and about as expensive on others.
Beat 403 minutes — what the day costs if you do all of it yourself. There is a third button that looks like the fastest thing on the board.
Play it before reading on. The interesting part is which jobs you kept.
The ledger
# You do not know in advance whether the answer is right - that is the entire reason checking
# exists. So each task carries an error rate, and the three options are compared on what they cost
# ON AVERAGE rather than with hindsight. Times are minutes; error rates are percentages; every
# figure below is held as hundredths of a minute so the arithmetic stays in whole numbers.
#
# name, do it yourself, write the request, check the answer, error rate %, fix a caught error,
# what an UNCAUGHT error costs later.
TASKS = [
("rename 200 variables", 45, 2, 5, 15, 5, 90),
("find the bug behind a failing test", 40, 3, 5, 30, 8, 200),
("convert a CSV to JSON", 15, 1, 2, 10, 3, 60),
("write a regex for this format", 20, 2, 3, 35, 4, 150),
("unit tests for a pure function", 30, 3, 6, 25, 8, 120),
("reply to a routine email", 8, 2, 2, 20, 2, 45),
("summarise a 40-page contract", 60, 2, 55, 45, 30, 400),
("cite sources for a claim", 25, 2, 20, 60, 15, 300),
("pick between three vendors", 90, 3, 85, 70, 40, 500),
("translate into a language you cannot read", 70, 2, 70, 50, 35, 350),
]
MINE, CHECK, SHIP = "do it myself", "delegate, check it", "delegate, ship it"
def costs(task):
_, mine, ask, check, err, rework, blast = task
return {
MINE: mine * 100,
CHECK: (ask + check) * 100 + err * rework,
SHIP: ask * 100 + err * blast,
}
def mins(hundredths):
return f"{hundredths // 100}.{hundredths % 100 // 10}"
def breakeven(task):
"""The longest a check can take before doing it yourself is cheaper."""
_, mine, ask, check, err, rework, _ = task
return (mine - ask) * 100 - err * rework
print("Every number is minutes, averaged over how often the answer comes back wrong.")
print()
print(f"{'task':<42}{'yours':>7}{'check':>7}{'ship':>7} cheapest")
print("-" * 88)
for t in TASKS:
c = costs(t)
pick = min(c, key=c.get)
print(f"{t[0]:<42}{mins(c[MINE]):>7}{mins(c[CHECK]):>7}{mins(c[SHIP]):>7} {pick}")
print("-" * 88)
all_mine = sum(costs(t)[MINE] for t in TASKS)
all_check = sum(costs(t)[CHECK] for t in TASKS)
all_ship = sum(costs(t)[SHIP] for t in TASKS)
best = sum(min(costs(t).values()) for t in TASKS)
print(f"{'do all ten yourself':<42}{mins(all_mine):>7}")
print(f"{'delegate all ten, check all ten':<42}{'':>7}{mins(all_check):>7}")
print(f"{'delegate all ten, check none':<42}{'':>7}{'':>7}{mins(all_ship):>7}")
print(f"{'choose task by task':<42}{'':>7}{'':>7}{'':>7} {mins(best)}")
print()
print(f"Checking never loses to shipping - not on one task out of ten. Skipping the check")
print(f"turns {mins(all_check)} minutes into {mins(all_ship)}, which is worse than doing all ten by hand.")
print()
print(f"Delegating everything and checking it saves {mins(all_mine - all_check)} minutes out of {mins(all_mine)}.")
print(f"Choosing task by task saves {mins(all_mine - best)}. Nearly all of the win is in WHICH tasks you hand over.")
print()
print(f"{'task':<42}{'to do':>7}{'to check':>10}{'check must beat':>17}")
print("-" * 78)
for t in sorted(TASKS, key=lambda t: -breakeven(t)):
verdict = "delegate" if t[3] * 100 < breakeven(t) else "keep it"
print(f"{t[0]:<42}{t[1]:>7}{t[3]:>10}{mins(breakeven(t)):>17} {verdict}")
print()
print("That last column is the whole rule: hand it over when checking costs less than doing.")
print("Difficulty never enters into it. Finding a bug is harder than reading a contract and it")
print("delegates better, because a failing test checks the answer for you and nothing checks a")
print("summary except reading the contract yourself.")Every number is minutes, averaged over how often the answer comes back wrong. task yours check ship cheapest ---------------------------------------------------------------------------------------- rename 200 variables 45.0 7.7 15.5 delegate, check it find the bug behind a failing test 40.0 10.4 63.0 delegate, check it convert a CSV to JSON 15.0 3.3 7.0 delegate, check it write a regex for this format 20.0 6.4 54.5 delegate, check it unit tests for a pure function 30.0 11.0 33.0 delegate, check it reply to a routine email 8.0 4.4 11.0 delegate, check it summarise a 40-page contract 60.0 70.5 182.0 do it myself cite sources for a claim 25.0 31.0 182.0 do it myself pick between three vendors 90.0 116.0 353.0 do it myself translate into a language you cannot read 70.0 89.5 177.0 do it myself ---------------------------------------------------------------------------------------- do all ten yourself 403.0 delegate all ten, check all ten 350.2 delegate all ten, check none 1078.0 choose task by task 288.2 Checking never loses to shipping - not on one task out of ten. Skipping the check turns 350.2 minutes into 1078.0, which is worse than doing all ten by hand. Delegating everything and checking it saves 52.7 minutes out of 403.0. Choosing task by task saves 114.7. Nearly all of the win is in WHICH tasks you hand over. task to do to check check must beat ------------------------------------------------------------------------------ pick between three vendors 90 85 59.0 keep it translate into a language you cannot read 70 70 50.5 keep it summarise a 40-page contract 60 55 44.5 keep it rename 200 variables 45 5 42.2 delegate find the bug behind a failing test 40 5 34.6 delegate unit tests for a pure function 30 6 25.0 delegate write a regex for this format 20 3 16.6 delegate cite sources for a claim 25 20 14.0 keep it convert a CSV to JSON 15 2 13.7 delegate reply to a routine email 8 2 5.6 delegate That last column is the whole rule: hand it over when checking costs less than doing. Difficulty never enters into it. Finding a bug is harder than reading a contract and it delegates better, because a failing test checks the answer for you and nothing checks a summary except reading the contract yourself.
The inversion
Look at two rows.
Find the bug behind a failing test: 40 minutes by hand, and it delegates beautifully — 10.4 minutes. Summarise a 40-page contract: 60 minutes by hand, and delegating makes it worse — 70.5 minutes.
Debugging is the harder task. It is the one you would describe as requiring judgement. It delegates better anyway, and the reason has nothing to do with the work: the failing test checks the answer for you in five minutes. Nothing checks a summary except reading the contract, which is the job you were trying to avoid.
That is the axis. Not how hard it is. Not how boring it is. How long it takes to find out whether the answer is right.
Where cheap checking comes from
The delegable tasks all share one property: somebody or something other than you can do the verifying.
- A test suite. Run it. Either it passes or it does not.
- A compiler or type checker. The answer is wrong in a way that announces itself.
- A diff. Two hundred renames are checked by reading a diff, not by reading two hundred lines.
- A single execution. A regex is checked by running it against the cases you care about.
- Your own instant recognition. You know whether a reply to a routine email is fine in seconds, because you would have known what to write.
And the tasks to keep share the opposite property. To verify a contract summary you must read the contract. To verify a citation you must open the source. To verify a vendor recommendation you must weigh the vendors. The check is the work. When that is true, delegating adds the cost of asking and gives you nothing back.
The translation row is the sharpest case: if you cannot read the language, your checking cost is not high, it is infinite, and no amount of model quality changes that. You are not delegating a task, you are choosing to trust an answer.
The third button
The lab has an option that looks like the fastest thing available: hand it over and ship it without reading it. It costs a couple of minutes and it is done.
It loses on all ten. Not most — all ten. Delegating everything and checking nothing costs 1,078 minutes against 403 for doing every job by hand, because the occasional error that gets through costs vastly more to unpick later than it would have cost to catch.
That is not an argument about AI in particular. It is the oldest result in engineering — defects get more expensive the later you find them — and skipping the check is just choosing to find them late. Unchecked output is not a saving. It is a loan, taken out at a rate you do not get told.
The rule you can actually apply
The last table converts all of this into one number per task: how long a check can take before doing it yourself is cheaper.
Hand it over when checking the answer costs less than producing it. Keep it when the only way to check is to do it.
Two things follow that are worth more than the rule itself.
Cheap verification is something you can build. The reason coding delegates so well is not that models are better at code — it is that code comes with test suites, compilers and diffs. Any task can be moved up this table by building it an oracle. Writing the test first, asking for output in a checkable format, requesting sources as links you can click: each one converts a keep-it task into a delegate-it task by attacking the check column rather than the work column.
A task with no cheap check is a task where AI does not help you yet. That is worth saying plainly because the alternative — delegating it anyway and not checking — is the row that costs 1,078 minutes.
And when you do delegate, say what you actually want in the first message: every decision you leave open is a round of correction, and corrections land when the conversation is at its most expensive.
What this page simplifies
- The numbers are stated assumptions, not measurements. Nobody has a validated error rate for their own tasks. What survives is the ordering, and it holds for any figures where checking is much cheaper than doing on some tasks and about as expensive on others.
- Expected cost hides variance. A task that is usually fine and occasionally catastrophic averages out on this table and does not average out in a career. Where the blast radius is large, the average is the wrong statistic and you should be checking well past the break-even.
- Checking is treated as reliable. Real checks miss things, and a check you perform sloppily because the answer looked plausible is worth less than its column suggests. Plausible-looking wrong answers are exactly what these systems are best at producing.
- Learning is ignored. Doing a task yourself builds judgement that makes you faster and a better checker later. Delegating it does not. Over a year that term can outweigh everything in the table.
- The list is ten tasks with no dependencies. Real work queues, blocks, and arrives while you are in the middle of something else, and the value of finishing something now is not modelled here.