5 min read

Why I stopped chasing perfect code

How building in public helped me recognise perfectionism, define a useful first release, and improve software through real feedback.

By Emmanuel Itighise

A finished mint-green modular object moving forward on an illuminated path, leaving unfinished wireframe designs behind on a dark workbench.

For a long time, I waited until the code felt perfect before shipping. There was always something else to tidy up: a component that could be smaller, a function that deserved a better name, or an abstraction that might make the next feature easier. Each change sounded reasonable on its own. Together, they gave me an endless reason to delay.

The difficult part was admitting that some of this work was procrastination disguised as craft. Cleaning up code felt productive, and it was comfortable. Publishing meant letting someone else decide whether what I had built was useful. As long as the project stayed in my editor, I could keep believing it was almost ready.

What actually makes a release ready

There is a real difference between improving a product and postponing the moment someone can use it. I still care about readable code, sensible structure, and tests that catch meaningful failures. But I have started asking a harder question before another round of polishing: what problem will this change solve for the person using it?

Sometimes the answer is clear. Fixing a form that loses someone's input matters. Checking that private information stays private matters. Making the main action work on a small screen matters. Those are good reasons to delay a release. Renaming an internal helper for the third time usually is not.

Feedback gives the next decision some evidence

Building in public changed how I think about readiness. Sharing a working version creates an opportunity to learn something I cannot learn by staring at the implementation. Can someone understand what the product does? Can they complete the main task without an explanation? Does the problem matter enough for them to come back?

Consider a simple project tracker. Before anyone uses it, it is easy to spend days planning flexible filters, reusable status systems, and a dashboard full of charts. But the first useful version might only need to let someone create a project, record the next task, and see what needs attention. Putting that smaller version in front of a few people can reveal whether the real friction is missing features or simply unclear labels.

That is the value of an early release: it gives the next decision some evidence. A confusing button is something concrete to fix. A workflow people abandon is something to investigate. Silence is less conclusive, but it can still prompt useful questions about who the project is for and whether the right people have seen it. Feedback needs interpretation; it does not automatically become a feature request.

Sharing the work also does not have to mean a big launch. It can be a short demo, a preview link, or a small release with a clear explanation of what works. A specific question helps more than a general request for opinions. “Where did you get stuck?” gives someone a useful place to start. So does “What would you expect to happen after this step?”

Define the smallest complete experience

The habit I want to keep is defining the smallest complete experience before I begin. Small should still mean usable. If the feature is a contact form, the job includes validation, a successful submission, and a helpful message when something fails. An attractive submit button alone is not a complete experience. Reducing scope means doing fewer things well enough to use.

Once that scope is clear, I can separate release blockers from improvements that can wait. Broken core behaviour, security issues, and inaccessible controls belong in the first group. Extra settings, speculative abstractions, and visual details that do not affect usability can go on a follow-up list. Writing them down makes it easier to move forward without pretending they do not exist.

Keep improving after the release

After shipping, the work continues. I can observe where people struggle, ask follow-up questions, and make the next change deliberately. Refactoring still belongs in that process, especially when it makes a needed change safer or easier. The difference is that I now have a concrete reason for it, rather than an imagined future where the architecture must handle everything.

I am also trying to measure progress by more than how busy development feels. Another evening of rearranging files can produce a large diff without making the product more useful. A smaller change that helps someone finish a task may matter much more. Useful questions are whether the main flow works, whether someone understands it, and what I learned from putting it in their hands.

I still feel the urge to make one more improvement before sharing. The goal is to recognise when that improvement is necessary and when it is a way to avoid uncertainty. Shipping gives me something real to learn from. Then I can improve the code and the product with a better understanding of what deserves attention.

Perfection is a moving target. A working release, an honest conversation, and a useful next iteration are things I can actually build toward.

About the author

Emmanuel Itighise

Emmanuel Itighise

Founder of Stepfi-App, @Pulsar-Stellar/sdk, and Trybe.

Emmanuel Itighise, known online as Emeditweb, is a full-stack and AI-native developer based in Lagos, Nigeria. He builds practical products and developer tools, with a focus on web applications, AI, and the Stellar ecosystem. He shares lessons from building in public, contributing to open source, and turning ideas into working software.