Planning matters more with a smarter model, not less

The question was reasonable: now that the model is better, can I skip the upfront planning? The honest answer is the opposite of what you would hope.

It is a tempting line of thought. Planning is overhead. It exists, partly, to compensate for a model that might go off the rails. So as the model gets stronger and goes off the rails less, surely the planning becomes more skippable. Let the good model just go.

I worked it through and landed on the reverse. A stronger model makes upfront planning matter more, not less. The intuition that planning is a crutch for a weak model has the mechanism backwards.

i.A better model drifts further before you see it

Start with what better actually means. A stronger model produces more output, faster, and more plausibly. Each of those cuts against you when the model is heading somewhere subtly wrong.

More output means more built on top of the wrong turn before anyone notices. Faster means it gets further down the wrong path per unit of wall-clock time. And more plausibly is the dangerous one: a weaker model’s mistakes often look like mistakes, rough, obviously off, easy to flag. A stronger model’s mistakes look like good work. They are coherent, confident, well-argued, and wrong, which is the hardest kind of wrong to catch in review, because nothing on the surface signals stop.

So drift does not shrink with a better model. It compounds further and hides better. The model is not more likely to drift; it is more likely to drift convincingly and at scale before a human is in a position to say no.

ii.An autonomous run has no mid-run checkpoint

Now add autonomy. When a model runs unattended, there is no human glancing at the work halfway through to course-correct. The run starts, executes, and finishes, and the first review happens at the end, on the whole output. There is no moment in the middle where drift gets caught early and cheaply.

That removes the safety net that interactive work has. In a conversation, I can see a wrong turn at turn three and redirect before it costs anything. In an autonomous run, turn three’s wrong turn is still wrong at turn thirty, and I do not see it until the run hands back a finished thing built entirely on it. The only thing standing between the start and that finished output is the plan I wrote before it began.

iii.The plan is the target

This is why the plan matters more, not less. The plan is the only target the run is accountable to. It is the specification of what good looks like, written down before the run could drift, that I can hold the output against when it comes back. Without a plan, the output is accountable to nothing; I am reduced to judging whether it seems fine, which is exactly the judgment a plausible-but-wrong result defeats.

And here is the part that ties it to model strength. A better model hits the target you give it more precisely. Give it a sharp plan and it will execute that plan with more fidelity than a weaker model would. But give it an ambiguous plan, or no plan, and a stronger model does not save you, because there is no such thing as precisely hitting an ambiguous target. The model’s increased precision is wasted, or worse, it precisely builds the wrong thing the ambiguity allowed.

iv.Plan harder as the model improves

So the practice runs against the instinct. As models get stronger and autonomy gets longer, plan more carefully, not less. Write the target down. Make it specific enough that a plausible-but-wrong output fails it visibly. Treat the plan as the contract the run is held to, because it is the only thing in the loop that exists before the drift and survives to the review.

The model is a better instrument every release. That is exactly why the aim has to get better too. A more precise instrument pointed at a vague target just gives you a more confident miss, delivered faster and harder to spot. The plan is the aim. With a stronger model, you need it more.

Drafted with Bishop, my AI partner.
Words picked, edited, and approved by me. Model provenance: Claude Code (Claude Opus and Sonnet)