The more you let it run alone, the more you have to say — not less

TL;DR

Intuition says an autonomous task needs less explaining. That is backwards. The higher the autonomy, the more context you need — because a supervised task still has a mid-course correction to catch a bad assumption, and an autonomous one does not. Every gap you leave, the agent fills with a plausible-sounding default, and you only see the consequence at the end. Front-loading context shrinks the gap-surface before you let go.

I handed an agent a long task, then did the exact thing I would later see was wrong: I trimmed the briefing. The logic in my head sounded perfectly reasonable — "this one runs end to end on its own, I am not sitting over it, why bother spelling everything out."

Forty minutes later it finished. The output was wrong — not wildly wrong, which would have been better, but wrong in the worse way: plausible on the surface, off by one unspoken assumption from step two that I had never made explicit. And because there was no checkpoint along the way, that assumption got to travel through everything that followed before I ever saw it.

I had trimmed the context at exactly the moment I should have poured more in.

01The inverse relationship intuition tends to flip

Intuition lines everything up on one axis: small jobs get few words, big jobs get many. So an autonomous task — which feels like "turn it loose and relax" — gets misfiled under say-less. But the thing that decides how much context is needed is not whether you are relaxed or busy. It is whether there is a mid-course correction.

✕ Supervised task — context can be thin

You watch each step; the moment it veers, you stop it right there

▼

Every gap in the brief gets filled through dialogue — you add what is missing when it comes up

▼

A wrong assumption travels one step before it is caught — small risk surface

✓ Autonomous task — context must be thick

Nobody stops it midway; what you said up front is the whole of what it has to lean on

▼

Every gap becomes a decision it guesses at — and it always guesses, never pauses to ask

▼

A wrong assumption from the start multiplies through every step — by the end, a fully skewed output

Same agent, same task — the only difference is whether someone is watching midway. That difference inverts how much context is needed, it does not reduce it. Letting go is not a reason to say less; it is the reason to say enough up front, because there will be no second chance to add more.

The key word is "guess." An agent hitting an ambiguity does not freeze and wait for you — it picks the most plausible-sounding default and moves on. When you are watching, that guess is harmless: it guesses wrong, you see it, you correct it. When you have let go, that same guess becomes the foundation for every step after. The context you front-load is precisely what shrinks the number of places it is forced to guess — and on a long task, every guess is an error seeded early.

02Four things to spell out before you let go

Front-loading context does not mean writing an essay. It means plugging the four kinds of gap an agent is most likely to fill wrongly when it runs alone:

Goal — what the end result looks like, not just the task to do

Not "write a function to process this list" but "write this function so that in the end it fits into that place, used in that way". Without the destination, the agent optimizes for the immediate job and drifts from what you actually need.

Constraints — the off-limits zones and invariants it must not change on its own

What is absolutely not to be touched, which conventions must hold, which limits are hard. This is where the agent tends to guess "I'll just change this to be tidier" — and on a long task, one wrong touch early drags the whole chain after it.

Success criteria — how it can tell on its own that it got it right

"Done," to an agent, means "out of steps," not "up to standard." Give it a self-check — what it has to pass, what good looks like — so it does not stop at surface-plausible and leave you to redo it.

Stop conditions — when it should halt and come back to ask instead of guessing on

The most forgotten one, and the most important for an autonomous task. Spell out: in which situations it should stop and report rather than decide. This is how you re-implant a checkpoint into the middle of a task that otherwise has none.

These four are not extra words for peace of mind — they are the four kinds of gap the agent is forced to fill with assumption if you leave them empty. Plugging them up front is cheap, once. Letting it fill them itself, you pay in forty minutes of running toward an output you have to throw away.

Look at the fourth one a little closer. The first three are pure front-loading — say it up front, then let go. The fourth is different in kind: it implants a stop back into an autonomous task, turning "run straight to the end" into "run until you hit something genuinely ambiguous, then pause and ask." It is the cheapest way to get back the mid-course correction that autonomy just took away from you.

03The cost of thin context is not paid up front — it is paid at the end

There is a reason this trade-off is so easy to keep getting wrong: the cost of trimming context sits at one end, and the feeling of saving sits at the other. At hand-off, cutting the briefing short feels light and fast, immediately. The bill arrives forty minutes later, as a skewed output you have to trace back to the original assumption — and by then you pay not just in wasted run time, but in the work of finding where it veered.

So the math is not in the minutes you save while typing the brief. It is in this: for a task with no one watching midway, every sentence you do not say is one the agent answers for you — and it answers just as confidently as when it is right.

The next time you are about to turn a long task loose and walk away, stop at exactly that reflex — "no need to explain much." That is the reflex that betrays you. The longer the task and the less it is supervised, the more what you said before pressing the button is all the agent has. Letting go is not the time to say less — it is the only moment you still get to say anything.