You have been there. The app looks finished. The screens render, the buttons click, the happy path demos beautifully. You tell yourself you are a weekend away from launch. Then a month passes, and you are still a weekend away. The app is almost done, and it stays almost done forever.
This is the 90/10 trap, and it is the single most common way vibe-coded projects stall.
Why vibe coding lands you here
Vibe coding is conversational and visual. You describe what you want, the AI builds it, you see it, you describe the next thing. The whole loop is optimized for the next visible step — which is exactly what makes it feel fast and fun. The trouble is that most of what makes software real is invisible. It never shows up on screen, so it never becomes the obvious next thing to ask for:
- Input validation — what happens on an empty form, a 10MB upload, a string where a number belongs.
- Authorization — making sure user A cannot read, edit, or delete user B's data.
- Error handling — what the user sees when the API is down or the database times out.
- Edge cases — the empty state, the duplicate, the race when two people click at once.
- Deployment — environments, secrets, migrations, a way to roll back when a release goes wrong.
None of it produces a satisfying screenshot, so in a conversation optimized for visible progress it all gets postponed. The result feels 90 percent done because the 90 percent you can see really is done. The remaining 10 percent just happens to be most of the actual engineering — and it is the part that decides whether real users and real money are safe.
And "later" never arrives, because nothing in the loop forces it to. The AI builds what you ask and stops. It will not volunteer that the delete endpoint has no ownership check, because you asked for a delete button and you got one. The button works. Ship it, right? You cannot prioritize work you cannot see — so the backlog of hidden work grows silently while the demo keeps getting shinier. That is the gap afterclick is built to close.
How afterclick gets you to actually done
An independent second eye that names the invisible work. afterclick runs a review engine — separate from the model writing your code — on the changes with real blast radius: auth, money, user data, production. When the agent ships a delete endpoint with no ownership check, a form with no server-side validation, or a payment path with no error branch, the engine reads the diff and surfaces it in plain language. The hidden 10 percent stops being invisible; it becomes a flag you can see and act on, advisory by default so you decide with your eyes open instead of discovering the gap in prod.
Ship gates that make done a checked event. afterclick puts real gates between your code and production. A deploy lock means one release goes out at a time — no two sessions clobbering each other into prod. A ship queue orders concurrent releases instead of letting them collide. Branch protection stops a careless push to your main line. A kickoff check makes the agent state the plan before it starts building. A release is no longer "the demo worked." It is a checked, recorded event, and the unglamorous-but-critical parts have to exist before the gate opens.
A definition of done you can read. Every flag, override, and gated release lands in an audit trail and a read-only human dashboard. So "is this actually ready?" stops being a gut feeling and becomes something you can look at: what was reviewed, what was gated, what shipped, and when.
Memory so postponed work does not get forgotten. afterclick keeps a cross-session memory board of goals, files, and decisions. The hidden item the second eye flagged today does not vanish when the chat closes — it is recorded, so the next session sees it instead of building over it. The 90/10 backlog stops being invisible and stops being amnesiac.
Advisory by default, enforce when it counts. afterclick is not there to wag a finger or slow you down — it is advisory with owner override, so you keep building fast. When you are ready to be strict about, say, production deploys, flip on enforce and the gate holds until you sign off.
In practice it looks like this: you are a weekend from launch, again. You flip on afterclick. The next time the agent touches the auth flow, the second eye flags that the password-reset endpoint never checks token expiry. You fix it in one pass. When you go to ship, the deploy lock confirms no other release is mid-flight and the kickoff and checks are recorded. The release goes out as an audited event — and this time, done is actually true.
| Stage | Vibe coding alone | With afterclick |
|---|---|---|
| Building a feature | Visible parts get built | Same speed, plus the second eye flags missing checks |
| The hidden 10 percent | Silently postponed | Surfaced on the risky calls, recorded so it isn't forgotten |
| Calling it done | "The demo worked" | A gated, audited release |
| Shipping to prod | Whenever, however | Through a deploy lock and ship queue |
| Proving it's ready | A gut feeling | A read-only dashboard and audit trail |
Done, for real
The 90/10 trap is not a discipline problem. It is a visibility problem, and you cannot out-discipline a loop that only ever shows you the fun part. afterclick gives you the other 90 percent of the team the AI is not: the reviewer who checks the risky calls and the gatekeeper who will not let a half-built release call itself finished.
It is free to start, one paste into your project. Claude is the developer. afterclick is everyone else — and everyone else is who gets you from almost done to done. Turn it on before the next "just one more weekend."