Ten Repositories, Zero Usable Applications
Ian Macabulos5 min read
Ten repositories. Zero usable applications.
That title is intentionally provocative. The projects were not all broken or literally unusable. Many had working features and had fulfilled their original purpose: an assignment was submitted, a demo worked, or an application was deployed. Looking back through my GitHub, though, I saw a lot of work that I did not feel ready to hand to someone else or maintain over time. I had often treated submission or deployment as the finish line, and revisiting the projects showed me what I had postponed.
Finishing was the goal
For a while, my pattern was simple: requirement, implement, submit or deploy, move on. Starting another repository felt like visible progress. I could point to a new feature or a new app and say I had built something. I rarely asked whether I would understand the code a few months later, or whether someone else could use the application without me explaining how it worked.
At the time, I measured a project by whether the required feature worked, whether I could demonstrate it, and whether I could turn it in before moving to the next thing. That was my mindset, not a problem with the assignments. The code could satisfy the requirement without being something I was proud to maintain.
The unfinished parts were often less dramatic than a broken core feature. An empty state might be confusing. An error might leave the user unsure what to do next. The interface could behave inconsistently across screen sizes. A flow might make sense only because I already knew what each step was supposed to mean. I would notice those things, then tell myself they were polish for later.
Later often meant never. Once I had submitted or deployed the project, I was already thinking about what to start next.
Going back was harder than starting over
Reopening an old project months later felt different from starting a new one. When I start something, the choices are fresh. I remember why a component exists, what an unfamiliar name refers to, and which shortcuts I took to get a feature working. Returning later removes that context.
I had to reconstruct it from the code. Some logic was harder to follow than I remembered. A few names that had seemed obvious while I was writing them no longer explained much. Duplicated code showed where I had chosen the quickest local fix. Some flows depended on assumptions that were never written down. Even basic configuration could take time to rediscover before I could make a useful change.
That made adding a new feature less straightforward than I expected. Before changing anything, I had to understand what the existing code was doing and whether its behavior was intentional. Sometimes I realized I would now make the interface clearer or choose a simpler structure. The code was not necessarily wrong; it was simply harder to work with than it needed to be.
On projects such as SubVantage, going back meant spending time understanding earlier decisions before I could improve the experience. That was useful in a way a blank project was not. Starting taught me how to get an idea running. Returning showed me whether the decisions I had made were understandable and maintainable.
Fewer projects, more attention
I did not stop starting new projects. I stopped assuming that starting something new was automatically more valuable than improving something I already had. Progress began to include the work that was less visible: making an error understandable, removing a confusing step, simplifying duplicated logic, or writing down an assumption so it would not have to be rediscovered.
When I returned to a project, I started asking whether another person could understand the main flow without a guided tour. I paid more attention to what happened when a request failed or a page had no data. I tried to notice when I was adding complexity because it helped the user or the code, and when I was adding it because it seemed impressive.
Those questions did not give every project a neat ending. Software can always be refined, and some projects are worth leaving behind. But deciding what to maintain became part of the work. Sometimes the right improvement was to remove a layer or narrow the feature rather than build one more thing on top.
What “finished” means now
I do not think finished means perfect, bug-free, or ready for every possible use. It means I can return to the project, understand how its important parts fit together, and make changes without guessing at every step. It means the main flows communicate their state, failures are handled as clearly as I can manage, and another person has a fair chance of using the software without needing me beside them.
There will still be bugs, rough edges, and decisions I would change later. The difference is that I no longer treat the moment a feature works as proof that the project is finished. Maintenance, refinement, and clarity are part of building software, not chores that begin after the real work is done.
Starting projects taught me how to build. Returning to them taught me how to finish.

