It started with something ordinary: watching my toddler use a physical timer to set boundaries around playtime and transitions. Twist the dial. Hear the click. Time feels real. I wondered whether a digital Pomodoro timer could feel that grounded — and whether I could actually ship one, not just design it.
I'm a product designer by training. This was my first time owning every step of a desktop app end‑to‑end. What surprised me wasn't how fast I could build — it was how much there was to learn to actually ship.
Finding the shape — without drawing a single design
I never opened a design file.
Every interaction started as an experiment. I began in VS Code with GitHub Copilot, feeding it pictures of the physical timer I have and iterating directly in code. The UI took shape through behavior and feel — guided by a mental model, the object on my desk, and a lot of prompting and iteration.
Then I tried Figma Make - because why not. With the same images and a simple prompt, it one‑shotted a clock UI that looked and behaved remarkably right — UI, interactions, look-and-feel. I was quite blown away, actually.
That was the pivot. I stopped looking for one perfect tool and started matching tools to phases. Figma Make helped me find the shape. VS Code and Cursor helped me turn it into a real system.
This felt like a meaningful shift in how design can happen: less about drawing artifacts up front, more about imagining clearly, expressing intent, and shaping the thing directly where it lives.
Rapid iteration and fine‑tuning
Designing the dial felt familiar. Implementing it didn't.
"Snap to minutes" sounded simple until it wasn't. Dragging the hand couldn't constantly update state. Snapping at the minute marker had to happen on release. Overshoot needed to be allowed. Settling had to feel intentional.
The physical dial was the anchor, but this was still a digital product. Presets and readouts needed to be fast and precise, without losing the calm, tactile quality of the interaction.
Nothing was broken — it just didn't feel right yet.
AI made that fine‑tuning approachable. I'd observe behavior, ask why something felt off, make a small change, test it, and repeat — until the interaction matched the taste I had in mind.
The sound that disappeared
Sound was meant to be subtle. It ended up teaching me a lot.
I explored free sound libraries, trimmed tiny fragments, and tuned them until they paired naturally with the dial — quiet, mechanical, easy to live with (thanks to ChatGPT)
Then the surprise: the ticking sound worked locally but vanished in the packaged macOS app. The completion chime survived. The tick didn't.
One sound was synthesized. The other relied on bundled assets, paths, and runtime assumptions.
It wasn't a sound problem. It was a shipping problem.
The gap between "working" and "shipped"
The app worked locally long before it was usable by anyone else.
MacOS security warnings sent me into code signing rabbit hole. CI builds succeeded but produced unusable artifacts. Secrets existed but were empty - result of not reviewing generated code. The website needed logic, not just copy. Even the app icon only became real once publishing forced the question.
None of this felt like failure. It felt like discovering a layer I hadn't been thinking about. Shipping turned out to be its own craft. Pipelines are systems. And there's a whole lot of effort in taking something that works locally to one that's shippable.
Building with AI, from the inside
As a product designer working on Visual Studio and GitHub Copilot, I also experienced this project through another lens: thinking about what it means to build next‑generation IDEs for professional developers while using AI as a first‑class collaborator.
I noticed how much context mattered, how progress indicators changed perceived speed, and how well today's tools understand entire repositories. Most real evaluation didn't happen in code — it happened by running the app and seeing how it behaved.
There's a lot here that carries back into my day job: designing AI interactions, surfacing progress clearly, managing context well, enabling powerful reviewing process, helping builders stay oriented while real work happens.
What changed for me
realpomo isn't a big app. That's the point.
AI let me experience the full end‑to‑end arc of building software myself, over a weekend. That built real empathy for the many disciplines that come together to ship a product — and gave me a Pomodoro timer I could genuinely use.
I set out to design a timer app for personal productivity. I ended up learning how real software gets made. That shift has been the most valuable part of this project.