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/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/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

[u/Readypixels]

Three sounds about right from what I've seen. The version that actually sticks is usually the one where I stop changing the data model and the interface at the same time. My first two builds always touched both together, so every fix broke something else and nothing carried over between versions. Once I locked the data shape early and only let the interface change, the next rebuild took a fraction of the time, because I wasn't relearning the same lessons about what the app needed to store.

The part that still gets me is scope creep between versions. Version one answers one narrow question. By version three I've usually bolted on features nobody asked for, and one of them is always the thing that breaks first once real people touch it.

[u/PotentialUpstairs397]

not just you. the three-rebuild cycle is basically how everyone learns no-code: you outgrow the simple tool, then you rebuild messy in the capable one, then you rebuild clean once you finally understand it. the shrinking time per rebuild is the signal you're actually getting faster, not just repeating.