How much to let AI decide
There are roughly three shapes a piece of AI work can take. One call, where you ask and act on the answer yourself. A workflow, where you set out the steps and it fills them in. Or an agent, left to find its own way to the goal. The usual advice is to pick the one that fits. That advice is not wrong exactly, but it puts the choice in the wrong place: you do not really pick a shape. This is the decision underneath Prompt engineering with Claude.
Say it another way
A head chef does not decide how much freedom the kitchen has as one big decision. It gets settled dish by dish, in what the recipe card actually says. Where the card gives a weight, that is decided. Where it says nothing, the cook works it out at the stove. Nobody announced a policy on autonomy. It is just the sum of what got written down.
You do not choose a shape. You choose what to decide.
Every job is a run of forks: what happens next, then what happens after that. Each one is settled in exactly one of two places. Either you wrote it down before anything ran, or the system works it out in the moment. There is no third option where a fork decides itself. There is none where it goes unanswered either. Something answers every one.
So the shape is not a thing you select from a menu. It is what you are left with once you have gone through the forks and kept some. Keep all of them and you have written a single call: it tells you something, you do the rest. Keep the order of the steps but not their contents and you have written a workflow. Keep only the tools and the boundary around them and you have written an agent. Nobody sat down and picked agent. They just handed over enough forks that agent is what it turned into.
| The shape | Forks you kept | Forks it decides |
|---|---|---|
| One call | All of them. You take the answer and act on it yourself. | None. It answers, it does not do. |
| A workflow you orchestrate | The order of the steps and which one runs next. | What goes in each step. |
| An agent | The tools it has and the guardrails around them. | Which tool, when, in what order, how many times and when to stop. |
Leaving a fork out is a decision too
This is the part that catches people. A fork you did not think about is not a fork that stays open. It gets decided anyway, at runtime, by the thing holding the pan. Not out of mischief, but because something has to answer it and that is the only thing there. Silence is not neutrality. It is a decision handed over, handed over just as completely as if you had written "your call" in the gap.
Which means you cannot avoid the question by not asking it. Skip it and you have still answered, you have just answered by default and without noticing. The only real choice is whether you are the one who knows what you gave away.
Say it another way
The written recipe is the part you decided. Every step you left off, the cook fills in at the stove, not out of mischief but because someone has to and he is the one holding the pan. A gap in the method is not neutral, it is a decision handed over. Write nine steps of ten and you have not written a recipe with a hole in it. You have hired a cook for step ten.
Predictable is not the same as right
Writing a fork down is what makes the path predictable. That is exactly what it buys you. It is worth buying: you can look at what you wrote and know what will happen. Where nothing is written, the system predicts the next move instead, which is a fine thing to want when the answer needs weighing up and a bad thing to discover when it did not.
But predictable is not the same as right. Write down a fork that genuinely needed judgement and you have not made it certain, you have frozen a guess and made it repeatable. It will now take the same path every time, including the times it should not have. So the question for each fork is the one on When to use AI and when not to: can this be stated exactly? Does it need weighing up? That test does not change. This is just the same test asked about what happens next, rather than about a value.
The good news is that this is a decision you can make deliberately rather than discover. Go through the forks. Decide, for each one, whether it is yours or its. Then you know exactly how much freedom you gave away, which is a very different position from finding out later that you gave away more than you meant to.
Doing this with Claude Code
Autonomy is not a setting. It is the sum of what you left unsaid, so decide it on purpose.
Count the forks, not the shape. Before you decide whether you want an agent, list the decisions the job actually contains and mark each one yours or its. The shape falls out of that list; it is not an input to it.
Treat a gap as a grant. Anything you did not specify has been handed over. That is fine when you meant it and expensive when you did not, so the question is only ever whether you noticed.
Write down what must not vary. The forks with real consequences, the ones with an exact answer, are the ones to keep. Spend your specifying there rather than on the parts that genuinely need judgement.
Do not freeze a judgement call. If a fork needed weighing up, writing it down does not make it certain. It makes it consistently wrong on the cases you did not foresee, which is harder to spot than an obvious mistake.
The wider set of decisions this sits inside is Prompt engineering with Claude. The test underneath it is When to use AI and when not to.