Type a sentence. Watch an app appear. Every AI app builder sells the same trick, and the trick works. I have watched non-engineers light up when a paragraph of intent becomes a running screen in ninety seconds. Then I have watched those same people hit a wall about three days later, and the wall is always the same shape.
The wall is a hundred silent decisions
The wall is not a bug. It is a hundred decisions the builder made on your behalf while you were watching the screen fill in. Should this be one table or two? What happens when the payment fails halfway through? Who is allowed to see whose data? The model guessed, shipped the guess, and moved on. Now those guesses are load-bearing, invisible, and wired into a working system that you have to unpick.
The demo optimized for the wrong moment. It made the first ninety seconds feel incredible and left the next three weeks feeling like archaeology, where you dig through generated code trying to reconstruct choices nobody ever wrote down.
The hard part didn't leave. It went dark.
The seductive story is that the builder made the hard part easy. It did not. The hard part of software was never the typing, it was the deciding, and the deciding did not go away when generation got cheap. It went underground.
Every one of those hundred choices still got made. A model made them, in a fraction of a second, optimizing for a screen that runs rather than a system that is right. The cost of those decisions did not disappear. It moved downstream, lost its paper trail, and waited. You inherit it later as a bug you cannot explain or a change you are scared to make, because nobody, human or machine, ever wrote down why it works the way it works.
That is the actual trade the builder offers. It does not spare you the decisions. It makes them for you, silently, and hands you the bill in a currency you cannot read.
Build the screens, leave them unwired
So what do you do instead. The move I keep coming back to is this: build the screens, and refuse to wire them up.
An unwired screen is a question you can look at. A wired screen is an answer you are now married to. Wiring is where the cost lives and where the lock-in starts, so keep the screens real but the plumbing absent. Buttons navigate by reference. Screens render with sample data. The flow between them is something you walk, not something baked into logic. You get to look at the whole product without having committed to any of it.
That changes the economics of iterating completely. You can spend tokens throwing five versions of a flow at the wall, walk each one, keep the one that feels right, and throw the other four away having lost nothing. If the surfaces are versioned and nothing is ever deleted, reverting is not a rescue operation, it is just picking an earlier version. Exploring a new idea costs almost nothing, and being wrong costs even less.
Compare that to the builder that wired everything on the first pass. Now every alternative you want to try means unpicking real code, and every revert is a small act of courage. The builder made the first version cheap and every version after it expensive. Unwired UI inverts that. It makes exploration the cheap part and defers the expensive commitment until you actually know what you want.
The unwired prototype is not a throwaway on the road to the spec. It is the spec.
Making the decisions visible again
This is the bet behind Appestry, the tool I have been building. Alongside those unwired screens it keeps the thing the builders throw away: the decisions, and the reasons behind them.
The shape of it is simple. Commitments get recorded as you make them, and you are allowed to just decide, as long as you decide out loud instead of invisibly. Open questions are treated as the most valuable state in the system, because an open question is exactly what a builder would have silently guessed. Claims about the world carry where they came from, so nothing is quietly assumed to be true. And features are not where you start, they are what a decision produces once it is solid. The decision comes first, always, and the screen and the feature hang off it.
The rule I care about most is the quiet one: the machine proposes, organizes, and drafts, but it never rules. A human decides, and that gesture is the only thing that moves anything. In a world where a model can generate infinite plausible screens, the scarce act is judgment. This one, not that one, and here is why. The whole thing is built so the deciding stays visible, attributed, and yours.
Earn the right to hand it off
Here is the part that sounds backwards. Planning more is how you earn the right to let agents build.
What you hand an agent at the end is not a vibe and not a paragraph. It is a set of decisions with their reasons written down, and unwired screens that show what the thing is supposed to feel like. A vague brief means the agent guesses, and a guess puts you back at the wall. A sharp one means you can hand off the whole thing and check what comes back against decisions and screens you can actually point to. And when you change your mind later, it is a named move rather than an archaeology dig, because the reason was never a secret in the first place.
Plan more, and you build less by hand, and what little you do build is the right thing.
When not to bother
I do not think this is always right. If I am genuinely exploring, poking at an idea to see if it has legs, a builder is perfect and this discipline is pure overhead. Throwaway code should stay cheap and unexamined and unmourned.
The catch is that the moment code stops being throwaway is the moment the missing decisions start charging you interest. And that moment arrives earlier than almost anyone expects.
So the question I would ask before opening any builder: do I know what I am building, or do I just want to watch something appear? Those are different needs. The tools are extraordinary at the second one. The first one is still on you, and it is still the hard part.