Lessons From A Four Hour Application
A friend and I were trying to decide something over chat.
It was the sort of small, entirely ordinary problem that a wheel spinner ought to solve. Put the options in, give it a spin, let the wheel take responsibility for the decision. Excellent. We could get on with our lives.
Except the spinners I looked at didn’t give me the combination I wanted: a wheel I could send to someone else, with a result that became permanent after the first spin.
A screenshot leaves a fairly obvious question unanswered. Was that the first spin? Or the fifth, once the wheel finally developed the good sense to agree with you?
I wanted us both to be able to open the same link and see the same answer. One spin, then it’s settled.
Within four hours, that little irritation had become One & Spun: a named, branded, working web app, live on its own domain. AI helped me get from the initial idea through the product definition, identity, design, development and deployment.
The only new purchase I needed for the project was the domain.
That has made me think quite differently about which ideas are worth making.
Start with the promise#
I started by asking for a product requirements document. A fairly serious beginning for a colourful wheel that might end up choosing someone’s dinner, but it helped make the important bit explicit.
The product had to keep one promise: the first spin on a shared wheel would save a result that everyone opening that wheel would see afterwards.
That requirement shaped the rest of the experience. Making the wheel shouldn’t accidentally use up its spin. Sending it to a friend should give you a link. You should also be able to spin it yourself. Once the result was locked, duplicating the wheel could create a new one whilst leaving the original alone.
Writing that down gave us something to judge every subsequent decision against. It also gave the AI a useful problem to work on, with behaviour we could actually check.
Give it an identity#
The AI helped with much more than the code.
We worked through naming and finding an available .com, arriving at One & Spun. I bought the domain. We explored logo options, chose a direction and made an asset pack with transparent versions of the mark.
For the design language, I pointed towards Kahoot and Jackbox Games: something playful, colourful and a bit cartoonish. The result had bold outlines, a purple and cream palette, bright slices and a logo that brought the wheel and lock into the identity.
That mattered. This was a little social object we wanted to send to a friend. It needed to look like something you’d enjoy using.
I could describe a feeling, look at options, choose what worked and carry that decision into the interface. The same conversation could move from the name to the logo to the behaviour of the product.

The next version was where it got interesting#
Having something in front of me made the next decisions much easier.
The early versions had too much copy. The spin control felt disconnected from the wheel. Sharing involved an unnecessary change of page. These were things I could see and react to once the idea had become an interface.
At one point, my feedback was: “Why beneath the wheel? Why not let me actually spin it?”
That became a direct interaction. You could drag or flick the wheel itself, or tap its centre. We kept the wheel inert whilst you were creating it, then made the separate spin screen feel like a wheel you could play with.
Sharing changed too. Pressing “Send to a friend” would seal the choices and reveal the link inline. You could copy it straight into the chat you were already having.
The feedback kept getting more specific. Start fresh should mean a blank wheel. Clicking the logo should make a new one. Empty options should be removable directly from the error message. A shared link should load its wheel without briefly flashing the homepage first.
Then there were the little things that make a product feel alive: sound effects, a mute control, a bigger spin icon and confetti that looked less like it had been arranged by a committee.
One change was particularly revealing. When you pressed to spin, the wheel initially waited for the server before moving. The underlying result was being handled sensibly, but the interaction felt slow.
We changed it so the wheel started moving immediately, then landed on the result saved by the server. The promise stayed intact, and the experience became much more satisfying.
This was the part that really struck me. I could notice a problem, describe why it felt wrong, see the change and make another judgement whilst the experience was still fresh in my mind.
Revising the idea was cheap enough that I kept doing it. A working first version became an invitation to pay closer attention.

A playful product still has to keep its promise#
The permanent result was the whole reason for making this, so it needed more than a disabled button.
The result is saved on the server. Refreshing the page, opening another browser or retrying a request brings back that same result. A separate result link lets someone view it without giving them the ability to spin.
We tested a hundred competing spin requests against one wheel and checked that they all returned the same saved outcome. We checked retries, separate browser sessions and existing results surviving deployments. By the final pass, there were 27 automated tests, alongside checks of the live app on desktop and mobile.
I found this part of the collaboration useful too. I could insist on the behaviour that mattered, and the AI could help implement it and test whether it held up.
The silly wheel had acquired a rather serious obligation. If you’re going to settle an argument about a decision, you probably shouldn’t introduce a new argument about whether the decision counts.

Get it into the world#
The code went into GitHub, and we deployed the app entirely on Cloudflare, using a Worker and a D1 database.
There was some ordinary friction along the way. Connecting Cloudflare took a few attempts. I still had to authorise access to the accounts and buy the domain. Once the connections were in place, the AI could help configure the resources, deploy the app and check that it worked at the real address.
We also set up automatic deployment. A push to the main branch runs the tests, builds the app, applies pending database migrations and deploys it.
That made further improvements easy to put into people’s hands. We could refine the product and use the same route to release the next version.
Even the finishing work could happen in that flow: shorter sharing links, the redirect to www, search-term research, page titles, descriptions and the explanatory “What’s this?” modal.
By that stage, I could send someone a URL and they could use the thing. The idea had made it all the way out of the conversation.
Smaller ideas become worth trying#
The cost is worth dwelling on.
For this project, my only new purchase was the domain. I was able to use the AI tools and infrastructure available to me to make and launch the app.
That changes the calculation you make when you spot a small problem.
A lot of ideas get abandoned somewhere between “that would be useful” and working out what it would take to make them. There is time to find, a collection of skills to bring together and enough uncertainty to make doing nothing quite an attractive option.
When the time and extra cost of trying something come down, more ideas become reasonable experiments.
An idea can be worth making because it helps a few friends. Because it saves a repetitive job. Because it makes a hobby more enjoyable. Because it would be funny to send someone a wheel whose decision they can’t quietly replace.
It can earn its existence at that scale.
One & Spun solved a small problem I had actually encountered. Making it was also enjoyable. That was enough to get started, and the cost of finding out was low enough to follow it through.
More people get to make things#
This is where the democratisation of creating starts to feel concrete to me.
AI can help someone move across the different kinds of work an idea needs: defining what it should do, finding a name, exploring an identity, designing an interaction, writing the code, testing it and getting it online.
That gives more people a practical way to participate in making things. A designer with a very specific frustration. A teacher who knows exactly what would help their class. Someone who has been doing the same awkward job in a spreadsheet every week.
Those people already have something valuable: familiarity with a problem and a sense of what would make it better. AI gives them more ways to act on that knowledge.
My judgement stayed involved throughout this project. I chose the direction, challenged the awkward interactions and kept returning to what the app was supposed to do. The AI made it much quicker to turn those judgements into something I could use and assess.
The smallness of this project is what makes it encouraging. A decision wheel can be worth an evening. So can plenty of other ideas that have been waiting for the effort of making them to feel proportionate to their purpose.
Give your idea a day#
Look at the things you’ve found irritating recently. The workaround you keep explaining. The missing tool your friends joke about. The little thing you’ve caught yourself wishing existed.
Pick one you understand well enough to describe.
Start with what it should do for someone. Give it a name. Make a first version. Use it. Be specific about what feels wrong. Change it. Put it in front of somebody else and pay attention to what happens.
You can let the idea become clearer as you make it. That was one of the best parts of this whole process: being able to learn from the thing itself quickly enough to do something with what I’d learnt.
We have a much more accessible way to take the small, useful, odd and joyful ideas in our heads and give them a chance to exist.
There are ideas sitting in your group chat right now.
Give one of them a day. Go and make something.
← All essays