Take a real MVP — call it 1,249 commits from an empty repository to the first paying user — and read the history end to end. It's a confession. The log records not just what got built, but every time the plan changed mid-flight, every assumption that turned out wrong, and every hour spent undoing work that shouldn't have been written yet.
The history has a shape
Almost every from-scratch build follows the same curve: a burst of scaffolding, a long productive middle, and — threaded through all of it — a surprising amount of churn. Commits that rename a concept, rework a data model, revert a direction, or start with the word "actually." Those aren't progress. They're the cost of decisions made too late.
Rework is the tax on unclear requirements
Skim the messages and a category jumps out: "fix," "revert," "rename," "refactor X now that we know Y." In a typical solo MVP, a large share of commits aren't new capability at all — they're the codebase catching up to a decision that finally got made. The schema changed because the feature list wasn't settled. The auth flow was rebuilt because "users" meant something different than first assumed. None of it was avoidable in the moment — but most of it was avoidable up front.
The commits that never needed to happen
The expensive rework clusters around a few decisions: the data model, the core domain nouns, and the boundaries of v1. Get those wrong early and every later commit pays interest. A field renamed in week one is a find-and-replace; the same rename in week six touches migrations, types, UI, and tests. The history is a ledger of interest paid on decisions deferred.
What a plan would have collapsed
This is the case for planning, made by the commit log rather than by a consultant. A written spec — problem, scoped features, a data model, acceptance criteria — doesn't make you a better programmer. It front-loads the decisions that are cheap to change in a document and ruinous to change in code. That's doubly true when an AI agent is doing the typing: it produces rework faster than you can read it, so an unclear requirement doesn't cost you an afternoon — it costs you a thousand lines.
The takeaway
You'll never reach zero rework; discovery is part of building, and it should be. But the difference between 1,249 commits and 1,249 productive commits is how many decisions you made before the first line of code, not after. Spend an hour on the blueprint and the history reads like a build, not a confession.
That hour is the one InitRepo gives you back — a full planning suite from a short questionnaire, so the expensive decisions get made on paper first. Start with the plan.