Perfectionism vs. Just Ship It

The Person Who Started Refactoring 3 Hours Before Deploy

That would be me. Last Friday, 3 PM. Deploy was scheduled for 6 PM. The feature was working. Tests were passing. But the code didn't feel right.

One function was 47 lines long. Needed to be split up. The variable name data was too vague — should be userActivityLogs. Error messages could be more specific.

I started refactoring at 3. Thought I'd finish by 4:30, but it dragged to 5:20. I'd touched other parts along the way. Two tests broke. Got them fixed by 5:40. Twenty minutes before deploy.

My hands were shaking when I put up the PR. I told the reviewer "did a quick refactor, please take a look." The reviewer's expression was not great.

(I keep doing this and I can't stop.)

Working Code vs. Beautiful Code

"Done is better than perfect." The quote reportedly on Facebook's walls. I know it. I agree with it. I just can't practice it.

My head knows "if it works, it's fine," but my gut screams "this isn't right." Deploying messy code feels like going out with a stain on your shirt. Only I know it's there, but it won't stop bugging me.

But here's reality: users don't see the code. For users, it's either the feature works or it doesn't. Whether I split a 47-line function into three or not makes zero difference to the user experience.

So who is the perfection for? It's for me. For my ego. It took three years to figure that out.

Incidents Caused by Perfectionism

Perfectionism has caused actual incidents twice.

First time: "just one more thing" right before deploy and I accidentally messed with the production DB migration script. Rollback took 1 hour and 17 minutes. The entire team stayed late.

Second time: "I don't like this architecture" led to spending two weeks on refactoring that was supposed to be feature development time. It pushed the sprint, and the refactoring result wasn't even that impressive.

After experiences like these and still not being able to drop the perfectionism, I think this is in the personality territory.

I Envy the "Just Ship It" People

There's one person on my team who actually practices "deploy first, fix later" even when the code is a bit rough. They open PRs at twice my speed.

At first I thought "that'll pile up tech debt." But a year later, the tech debt existed but wasn't critical. Their cycle of shipping fast, getting feedback, and iterating was actually more efficient.

Meanwhile, I'd try to make things perfect, delay the deploy, get feedback late, and sometimes have to rewrite because requirements changed in the meantime.

Anyone can see "just ship it" is the right call. But my head and my hands aren't on the same page.

Searching for a Middle Ground

I can't fully abandon perfectionism. So I set rules:

1. No refactoring on deploy day.
2. Keep a "fix later" list — just write things down.
3. Refactoring gets its own separate ticket.

In theory, perfect rules. Compliance rate: about 60%. The other 40%, I still fall into "just one more thing" mode.

I think a truly mature developer is someone who can tolerate imperfection. I'm not there yet.