The first version of Modern Retro was embarrassing. The AI-generated images had warped text, bizarre colour bleeding, and at least three that looked more like fever dreams than vintage retail stores. The layout was a basic grid with no hover states, no animations, no personality. If you saw it today you wouldn't believe it was the same project.

It shipped anyway. And that was the best decision I made.

There is a specific kind of paralysis that comes from caring about quality. You can see what good looks like -- you've spent years studying it, curating it, developing taste around it -- and the gap between what you've made and what you know is possible feels unbearable. So you keep tweaking. Keep refining. Keep waiting until it feels ready. And "ready" never comes because your standards keep rising to match your improvements.

This is the perfectionism trap, and it kills more projects than bad ideas ever will.

The ugly phase is mandatory

Every product I've built has gone through an ugly phase. Not optional. Not avoidable. Mandatory. The first version of Little London was a flat list of activities with no filtering, no categories, and a colour palette that looked like it was chosen by someone with a grudge against aesthetics. The first Forest Quiz had questions that didn't work properly and a timer that occasionally counted up instead of down. CultureTerminal's first iteration looked like a spreadsheet someone had accidentally published.

All of these are now products I'm proud of. But they got there by being terrible first.

The gap between version one and version ten is where all the learning happens. You can't skip it. You can't plan your way around it. You have to build through it.

The reason version one has to be ugly is that you don't actually know what the product should be until it exists. You think you do. You have a vision, a plan, a mental model of what it will look and feel like. But the moment it's real -- the moment you can click through it, use it, show it to someone -- you discover things that were invisible in the abstract. The spacing feels wrong. The navigation makes no sense. The feature you thought was essential is irrelevant. The thing you almost left out is actually the whole point.

What shipping teaches you

You cannot learn these things without shipping. They don't reveal themselves in mockups, wireframes, or mental models. They only appear when the product is live, in someone's browser, being used for its actual purpose. This is why version one has to exist, and why it has to ship even when it makes you uncomfortable.

🎯
The uncomfortable truth: If you're not slightly embarrassed by version one, you waited too long to ship it. The embarrassment is information. It tells you exactly what to fix next.

Modern Retro is now on something like version twenty. Each version taught me something the previous one couldn't. Version two fixed the layout. Version five added proper image generation with better prompts. Version eight introduced the scoring system. Version twelve added print sales through Printful. Each iteration was small, but the compound effect is massive. The product that exists today is unrecognisable from where it started. And it only got here because version one -- ugly, incomplete, embarrassing version one -- was allowed to exist.

Perfectionism in advertising

I spent fifteen years in an industry that worships perfectionism. In advertising, you don't ship until the creative director signs off. Until the client approves. Until legal clears it. Until the production team polishes every frame. There's a reason for this -- you're spending someone else's money, and the work represents their brand. Imperfection has real consequences.

But that instinct, the instinct to perfect before releasing, is catastrophic when you're building your own products. Because there's no sign-off meeting. There's no deadline forcing you to stop tweaking. There's no client saying "this is good enough, let's go." It's just you, your standards, and an infinite timeline. That combination produces exactly one thing: nothing.

The shift I had to make was from "is this good enough to present?" to "is this good enough to learn from?" Those are wildly different bars. The first one requires polish. The second one requires function. The first one is about impressing people. The second one is about making progress.

Perfectionism feels like quality. It's actually fear wearing a nicer outfit. The fear that the work won't be good enough, dressed up as the conviction that it isn't ready yet.

The version-two advantage

Here's the thing about shipping ugly: it creates momentum. Once version one is live, version two becomes obvious. You can see what's broken because real usage breaks things that testing doesn't. You can see what's missing because actual users -- even if the only user is you -- reveal gaps that planning never anticipated. You can see what's unnecessary because the features nobody touches stand out immediately.

Version two is always better than the version one you imagined but never shipped. Always. Because version two is informed by reality. The imaginary perfect version one is informed by assumptions. And assumptions, in my experience, are wrong roughly 60% of the time. Which means the product you refused to ship because it wasn't perfect was also wrong about 60% of the things you were perfecting.

I have fourteen live products. Every single one started ugly. Every single one got better through iteration. And every single one taught me the same lesson: the courage to ship something imperfect is worth more than the patience to wait for something perfect. Because perfect doesn't ship. Imperfect ships, learns, and iterates. And iteration, compounded over weeks and months, produces something that patience alone never could.

Version one is always ugly. Ship it anyway. Version two is waiting.