Why AI-generated apps compile but do not work
If you have used an AI builder for anything real, you have seen this: the code generates, it type-checks, the preview loads, and the thing does not do what you asked. Nothing errored. Every signal said success.
That gap is the whole problem, and it is worth being precise about why it happens.
Compiling only proves it parses
A compile check answers one question: is this valid code? It cannot answer whether the code does what was asked. A file containing a heading and a comment saying the rest goes here compiles perfectly. So does an app with a filter that is wired to nothing.
This is why a stub is the worst failure mode available. An app that crashes tells you something is wrong. An app that compiles, loads, and quietly omits half the request tells you nothing at all.
How they actually fail
- Scaffold text left in place — a comment where a feature should be, shipped as if it were finished.
- A requested capability with no trace in the code at all. You asked it to save your data; nothing ever writes it.
- A component that builds an interface and never returns it, so the screen is blank.
- State nothing can change: a filter exists, the list is correctly filtered by it, and no control anywhere can set it. The feature is written and permanently unreachable.
- An input you cannot type into, because what it displays and what it updates are two different things.
Every one of those compiles. Most of them look right in a screenshot.
What Adrian checks beyond compiling
After the compile gate, Adrian reads the code it just wrote and checks it against the request. The checks are deterministic — they report what can be proven from the source, not a second model's opinion, because a judge that can hallucinate cannot be the thing that catches hallucination.
It looks for the failures above: leftover scaffold text, requested capabilities with no implementation, components that render nothing, state with no way to change it, controls that cannot be operated. It also checks the visual result for the tells that mark a generic template — default font stacks, untinted greys, elements left completely unstyled.
What happens when it finds something
Findings are not a report you have to read. They are handed back to the coder as specific instructions — which state, which setter, which control is missing — and the build repairs itself before you see it. Then the same checks run again, so whether the repair worked is measured rather than assumed.
What this does not claim
This is a floor, not a guarantee. Passing every check means nothing provable is wrong — it does not mean the app is good. A check that cried wolf would get switched off and then catch nothing, so each one stays silent unless it can prove the problem from the code itself.
The point is not that generated code is now perfect. It is that the obvious, checkable failures should never reach you with a success message attached.