Your coding agent doesn't need a better model. It needs a better plan.

Agentic coding has a strange failure mode. The agent is more than capable of writing the code — but it confidently builds the wrong thing, fast.

You give it a loose description, it fills the gaps with plausible guesses, and three hundred lines later you realize it assumed Postgres when you meant SQLite, or optimistic concurrency when you needed a lock. The model wasn't the bottleneck. The shared understanding was.

The reasoning evaporates

When people pair-program, that understanding is cheap. You hold the plan in your head, you talk, decisions get ratified in a code review, and the why behind each choice is recoverable. With an agent, all of that lives in a linear chat that scrolls away. By the time the session is long or the codebase has grown, the reasoning for a decision is gone — so the agent re-derives it, and re-deriving means re-guessing. That's where implementation drift comes from: not a weak model, but a missing record of intent.

Planning is the highest-leverage move

In hand-written code, a wrong assumption costs you a few lines before you catch it. With an agent, a wrong assumption is amplified — it becomes the load-bearing premise of a lot of generated code, tests included. Fixing intent is cheap; unwinding confidently-wrong implementation is expensive. It's the old "cost of a bug rises the later you catch it" curve, except the agent moves the curve to the left and makes it steeper. The cheapest place to correct course is before a single line is written.

The plan is the new interface

This is the mental shift. When you work with an agent, the artifact you should be editing isn't the code — it's the plan. The code is downstream of it. Which means the plan can't be a throwaway sentence in a chat box; it has to be a real document: something you can revise, disagree with a specific line of, keep decisions attached to, and review changes against. Treat the plan the way you treat code — versioned, reviewable, durable — and the agent inherits a stable source of truth instead of reconstructing one every turn.

What "planning" actually means here

It's easy to hear "planning" and picture heavyweight, up-front, waterfall specs. It's the opposite:

• Separate deciding from building. Let the plan settle before the agent starts generating. A quick turn-based loop — draft, question, answer, revise — beats one long prompt and a wall of code you now have to reverse-engineer.
• Make the ambiguous decisions explicit, and leave the rest. You don't spec every line. You pin down the things that are irreversible or contested (the data model, the auth boundary, the concurrency choice) and let the agent handle the mechanical middle. Tracer-bullet the risky parts; don't gold-plate the obvious ones.
• Keep the rationale next to the decision. "We chose X because Y, and rejected Z" is worth more than the decision alone — it's what stops the same debate from reopening every session, and what lets a teammate (or the agent, next week) understand the shape of the thing.
• Review the agent's changes like a PR. When it revises the plan or the code, look at the diff and accept or reject — don't let it silently rewrite. The review is the alignment.

The honest counterpoint

You can over-plan. Speccing a CRUD endpoint to death is a waste, and a plan you write once and never touch rots as fast as stale comments. The goal isn't more planning — it's planning the right things, continuously, and letting the plan evolve alongside the code instead of freezing at the start. Under-planning makes the agent guess; over-planning makes you the bottleneck. The sweet spot is a living document that's just detailed enough to remove ambiguity where ambiguity is expensive.

The teams getting the most out of coding agents aren't the ones with the best prompts. They're the ones who treat the plan as a first-class artifact the human and the agent both edit — where questions get asked before code gets written, decisions carry their reasoning, and changes are reviewed, not assumed. The model will keep getting better. The plan is the part that's on you.