Sharpen the Axe: The Plan-First Way to Build With AI

Here is the pattern almost every beginner falls into. You open an AI tool, describe what you want in a sentence or two, and let it build the whole thing. It spits out a pile of files in one shot. Then you spend the next two days fixing what it got wrong — wrong database, wrong structure, a feature that fights the one before it. So you re-prompt, it rebuilds, and you're back in the same loop.

The split is roughly 80% building, 20% planning — and that's exactly backwards. There's an old saying (often pinned on Lincoln, though the attribution is disputed): "Give me six hours to chop down a tree and I'll spend the first four sharpening the axe." The AI is the axe. Most people swing a blunt one. Flip the ratio — plan most of the time, build a little — and the rewrites mostly stop, because the model isn't guessing what you meant as it goes. (80/20 is a heuristic for where your effort should sit, not a measured statistic.)

Before the AI builds anything, make it produce the full plan and agree on it with you. This is the highest-leverage step: the choices you lock here (the stack, the data, the screens) are the ones that are brutally expensive to change after code exists. You're not asking it to build — you're asking it to decide and show its thinking so you can approve it.

A plan you can't check off is still vague. Have the AI break the build plan into a numbered list of small, completable steps, each with a checkbox and a one-line 'done when…' definition. Small steps are the whole game: each one is easy to review, easy to approve, and easy to undo if it's wrong. If a step is too big to describe in a sentence, it's too big to build in one go — split it.

This is the step nearly everyone skips, and it's where right-first-time actually comes from. Don't let the AI build the whole thing in one shot. Have it implement one checkbox at a time, then stop. You review that step against the plan, approve it, and only then does it move to the next. The mess people complain about almost always comes from one giant uninterrupted build with no checkpoints. Frequent small approvals catch a wrong turn while it's one step deep, not ten.

Before you commit to the plan, get a second opinion from a model that didn't write it. Open a fresh AI session — a clean chat with no memory of the first conversation (a different tool is fine too) — paste in the plan, and ask it to find what's wrong. A fresh model has no stake in agreeing with the first one, so it questions assumptions the original quietly accepted: a stack choice that won't scale, a missing piece, a step in the wrong order. This 'adversarial review' is a documented best practice — the idea is to let a fresh model try to refute the work before you build on it. Two minutes here saves you the half-built rewrite later.

Use these in order. They work in any capable AI chat. If your tool has a dedicated plan mode (for example, Claude Code's plan mode, where it proposes a plan and makes no changes until you approve), switch it on for steps 1–3 so it can't start editing before you've signed off.

Plan-first won't kill every rewrite — a big, genuinely novel project will still surprise you, and no framework removes the need to think. But for the overwhelming majority of builds, a few hours of planning save you days of redoing. The goal isn't a perfect build on the first try; it's catching the expensive mistakes while they're still cheap — on paper, in the plan, before any code exists.