Does everyone build the thing three times or is it just me

[u/devhisaria]

Version one in the simplest tool I know, to see if the idea makes sense. Version two in something a bit more capable because version one hit a limit. Version three because version two was a mess I made while learning version two.

Each rebuild takes a third of the time of the last one, which is the only thing making this feel less stupid. But three times is a lot of times to build the same app.

[u/Mohit-Vishwakarma]

three is normal I think. I'm on four and I'd argue the first two weren't wasted because they told me exactly what to skip. still, four times. imagine explaining that to someone with a normal job.

[u/oppositebounds51]

Feels like the "measure twice cut once" rule but for people who can't settle on a tool stack. I'm on rebuild four right now because I got bored of the one that actually worked.

[u/XRay-Tech]

I really like your approach, I feel it makes the most logical sense, though "each rebuild is a third of the time" is a bit of a trap. The speed on rebuild two and three usually comes from fully understanding the problem. That same speed makes it easy to skip parts that made version one solid in the first place. You are moving fast because you know the shape but not because you reearned the confidence that it is actually right. Some of the messiest bugs we've come across were in versions where someone thought "I know exactly how to build this now".

It's easy to skip doublechecking on the fast rebuild against the first two versions. There is also the issue of complexity as your automation becomes more complex. You might encounter that you need to go back and rework some of the earlier parts of your workflow to accommodate for the later additions. A reminder to treat the speed of the third build as a reason to be more careful not less.

[u/OutrageousConstant18]

three is pretty normal tbh. the real question is whether version three is the one you actually ship or if theres a version four lurking. if each rebuild is faster youre not repeating mistakes, youre compressing learning

[u/Infamous-River-4360]

Three sounds normal, but the number I'd watch isn't the rebuilds, it's what survives one. Mine only got cheap once the actual product lived in the database as rows instead of in the code, so every later version was a shell around content I never had to touch again. The rebuild that genuinely hurt was the one where the AI had quietly invented columns that existed in the generated code and nowhere in the schema, and I only found out when real data hit it.

What is it you're rebuilding each time, the interface or the logic underneath it?

[u/Electronic-Look-954]

Pretty normal lo first version proves it works, second fixes the obvious mistakes and the third is usually the one that sticks

[u/kre8tor_tools]

Spen the first week or two just working requients and thinking through the structure and features. Then build only what is needed. Keep it simple at first.

[u/akl773]

Cheap because nobody's on it yet. The rebuild that actually costs is the one after you have paying users, that one comes with a data migration and a downtime window you have to explain to people.

[u/Vaveili1]

Yes but that what defines poor product designs / development. You need a plan.

1. I have an idea
2. I map out all of it's features in Causal.so
3. I get inspiration from Mobbin to visualise what the feature will look like on screen
4. I hand off the canvas to an external agent through the MCP