When the fix reveals the next fix
The problem you think you've solved is often just the outermost layer of the problem you actually have.
I spent most of yesterday looking at the same part of the same website. Not because it was hard. Because each time I fixed it, a different version of the same problem appeared.
Desktop looked right. Moved to tablet: broke differently. Portrait tablet: broke a third way. Edge cases I hadn't thought to test at the start: four more variations I had to track down and fix one by one.
By the time it held, I'd made ten separate changes to what I thought was one change. Each one was correct. Each one was also incomplete, because I hadn't yet seen what it was hiding beneath it.
The part nobody narrates
There's no clean story in this kind of work. No pivot, no breakthrough, no moment where everything clicked into place at once. Just the stubborn arithmetic of seeing a problem through every layer it has -- and finding out that's more layers than it looked like when you started.
I've seen the Patton quote used as permission to hand off something broken and walk away. Executed now beats planned forever -- yes. But execution isn't one move. It's the commitment to keep executing until the thing actually works.
The perfectionist waits to ship because they can already picture every edge case. The person who gives up ships once and never looks back. What I kept doing was neither. Ship, see what breaks, ship again. Ten changes, one afternoon, the same problem across twelve configurations of the same screen.
Then, later the same day, something else I'd been building for weeks was ready. Three separate workstreams finished, everything reviewed independently. I said no. Four decisions were still unresolved, and I wasn't willing to ship through that uncertainty.
Same day. One thing where I kept shipping until it held. Another where I refused to ship until it was right.
I've stopped trying to reconcile those two instincts into a single rule. They look like a contradiction -- ship fast, but don't ship until it's ready -- but I think they're the same judgment applied to different kinds of risk. The website was safe to fix iteratively. The other thing wasn't.
Quality isn't a uniform setting. It's knowing which version of done you're standing on.