The Plan Was Never the Point

An agent hands you a plan in twelve seconds. Reasonable, sectioned, ready to go. Here's why approving it is not the same as having one.

By Jason Waldrip, with Claude Opus 4.8

You ask the agent to scope the feature. Twelve seconds later you’ve got a plan. Sectioned, sequenced, a tidy risks heading at the bottom, the dependencies called out in order. It looks like the plan you’d have spent an afternoon on, and it’s faster and better formatted than the one you’d have written tired on a Thursday. You skim it. Nothing jumps out. You say go. Three weeks later you’re standing in front of a design decision nobody on the team can explain, because nobody on the team actually made it. The model made it. You approved it. And “approved” turns out to be a very different thing from “understood.”

I keep watching smart people walk into this, and they walk in precisely because the output is good. Bad plans get scrutiny. It’s the reasonable-looking ones that get a nod and a merge.

what planning was actually for

There’s an old line from Eisenhower that gets quoted to death and understood about half the time: “Plans are worthless, but planning is everything.” The military has known this longer than software has existed. Moltke got there in the 1800s: no plan survives first contact with the enemy. Both men spent their lives making plans. Neither thought the document was the deliverable.

Here’s what they meant. When you sit down and actually plan something, you simulate it. You run the system forward in your head, hit a wall, back out, try a different route, hit another wall. You argue with yourself about the case you’re pretending won’t happen. By the time you’ve got a plan, the plan is the residue of all that. The valuable part isn’t the residue. It’s that you now carry a map of the territory: why this path and not the three you rejected, where the load is, which corner you’re nervous about and why.

That map is what lets you adapt when reality does what reality always does and refuses to match the document. You don’t re-plan from zero. You consult the model in your head, the one you built by doing the work, and you adjust. The plan was meaningless the second it met production. The planning is what’s still paying you.

the artifact was always a byproduct

So here’s the move the agent makes, and why it’s so easy to miss. It hands you the residue and skips the fire. You get the document without doing the simulating. You hold a map of a territory you never walked.

It reads like a plan. It is, structurally, a plan. What it isn’t is yours. Nothing in your head changed when that file appeared. You can recite it. You can’t defend it, because defending it means knowing the three paths it rejected and why, and you were never in the room where those got rejected. There was no room. There were twelve seconds.

I learned this on the other side of it, the slow way, before any of this was automatable. The most useful thing anyone ever told me about scale is that it’s a design problem before it’s a code problem: decide where state lives before you write a single line. That sounds like advice about the answer. It isn’t. The value was never the answer, “state lives here.” It’s the argument you have with yourself getting there, consistency against availability, what you’re willing to lose in a partition, where the writes actually concentrate. Win that argument honestly and you can debug the thing at 2am, because you remember exactly which tradeoff you took and what it was supposed to cost. Skip it, let something else decide where state lives while you nod, and you’ve shipped a system you fundamentally cannot reason about. The agent will happily make that call. It does not have to wake up for the page.

generation is free, the understanding is the work

This is the same fault line I keep coming back to, just moved upstream. I’ve argued you multiply judgment by a fleet, never zero by a fleet, because anything times zero is still zero. Most people picture that at the code layer: the agent writes the diff, you catch what’s wrong. But the diff isn’t where the zero hides. It hides in the plan, one level up, where the decisions that shape everything downstream get made in a place you weren’t.

Letting the fleet generate the plan is fine. It’s good, even. What’s fatal is treating the generated plan as the planning. The output is the cheap part now, all of it, the plan included. The expensive part, the only part that was ever scarce, is a human carrying an accurate model of why the system is shaped the way it is. You don’t get that model by reading. You get it by interrogating: arguing with the plan, poking the case it waved off, asking it to defend the route it took over the one it didn’t, until the map is actually in your head and not just in the file. That’s not slower planning. That’s the planning, done on top of a draft instead of a blank page. The draft is a gift. Mistaking the draft for the work is the whole trap.

There’s a hard version of this I’ve said to more than one engineer: the shortcut you hand someone today is the context gap you own forever. Same physics here, except the someone is you, and the person you’re shorting is yourself in three weeks, standing in front of a decision with no idea how it got made.

so what do you actually do

You don’t stop generating plans. You’d be giving up a real advantage, and the blank page was never sacred. You change what you do with the draft.

1. Treat the generated plan as a question, not an answer. Its job is to give you something to argue with. If you find yourself agreeing with all of it on the first read, you haven’t read it, you’ve skimmed it. Go back and find the decision you’d have made differently, and make the plan tell you why it didn’t.
2. Make it show its rejected paths. A plan with no roads not taken is hiding the part that matters. Ask what it considered and dropped, and why. The discarded options are where the judgment lives. If it can’t produce them, that’s your signal the thinking didn’t happen.
3. Find the load-bearing decision and own it personally. Most plans have one or two calls that everything else rests on: where state lives, what’s the source of truth, which thing you’ll be unable to change later. Those you make yourself, by hand, with the argument fully had. Let the agent draft the other ninety percent.
4. Pass the empty-room test. Before you commit to it, ask whether you could defend the plan in a room where the model isn’t invited to help. If you can, the map is in your head. If you can’t, you have a document, and you should keep working until you have a plan.

None of this is anti-agent. I’d be a hypocrite, I wrote this one with a fleet at my elbow. It’s a warning about the specific way this era lets you skip the part that was always the point and not notice, because the thing you skipped used to leave an obvious gap and now leaves a polished file in its place.

So next time the plan shows up in twelve seconds, the question isn’t whether it’s good. It usually is. The question is whether you could stand up tomorrow and defend it without the thing that wrote it. If you can’t, you didn’t make a plan. You accepted one. And the bill for the difference always comes due in the same place: at 2am, in front of a decision nobody remembers making.