Plan AY: From Vibe Prototype to Viable Product — Pre-Launch Polish Checklist

Lock down requirements → make it testable → error handling → performance → maintainability → documentation

Time
0.5-2 days
Cost
Medium
Difficulty
Advanced

Best for

For the stage of polishing a working prototype into a shippable product, covering robustness and delivery quality — so it doesn't run locally but break in production.

Steps

Lock down requirements & acceptance criteria

30-60 min

Claude Code + you

Define what 'it works' means as verifiable acceptance criteria: the core paths, edge behaviors, and what must be handled versus deferred — so polishing doesn't go off the rails. Write out 'when X happens, then Y' cases as the bar for every round of changes.

💡A 'not in scope' list matters just as much; bounding the scope is how you keep effort on the critical paths.

Make the code testable

1-2 hours

Test framework + Claude Code

Add unit tests for critical logic and end-to-end tests for critical paths, so later changes stay regression-safe. Start with the logic most likely to break (data handling, state transitions, external dependencies), then cover the core user flows.

💡Drive real user paths with Playwright instead of clicking ten times by hand; make the suite reliably green before chasing coverage.

Error handling & edge cases

1-3 hours

Claude Code + Playwright

Handle empty states, failure states and invalid inputs one by one so you never show a blank screen or crash; write error messages for the user, not raw stack traces. Timeouts, abnormal API responses and missing data — things that never happen in 'normal' runs — are the most common failure points in production.

💡Use Playwright to simulate offline, slow responses and empty data to reproduce failure states; every error path needs a visible fallback message.

Performance & experience

1-3 hours

Browser DevTools + Claude Code

Use the DevTools Performance and Network panels to find load, interaction and response-time bottlenecks; optimize the slow parts first and avoid over-optimizing. Usually 80% of the gain comes from a few spots: big first-screen requests, uncached resources and render blocking.

💡Measure before you act and record before/after numbers; set a 'good enough' target (e.g. first screen under 3 seconds) and stop once you hit it.

Maintainability

1-2 hours

Claude Code

Unify naming, split oversized functions and files, add types and delete dead code so the project can be handed to someone else — or to you in three months. The temporary hacks and hardcoding from the vibe-coding phase get settled back into place here.

💡Have the AI do a 'readability pass' and confirm each change; keep commits small so everything stays reversible.

Documentation & handoff notes

30-60 min

Claude Code

Write down how to run it, environment variables, deployment steps, known issues and limitations — a README or handoff doc anyone can follow. Don't expect someone (or future you) to guess the startup command and prerequisites from the code.

💡Run the full 'clone to launch' sequence once and record it; every command that appears in the docs must actually work.

Tools involved

Pitfalls to avoid

Treating a working prototype as done

Running locally and staying up in production are different things: caching, concurrency, permissions and weak networks will trip you immediately. Walk through all six steps of this plan before launch.

Polishing without tests

Changes verified only by hand fix one thing while breaking another, with regressions caught by eye; automate tests at least for the critical paths so changes stay regression-safe.

Ignoring performance & edge cases

Testing only the happy path leaves empty data, failure states and slow networks all uncovered — and production will find them. Treat edge cases as first-class citizens, not afterthoughts.

No documentation, no handoff

If only you understand the code, the project goes dark when you leave or take time off; run and deployment notes are the cheapest way to keep it alive.

Related Workflows