Over the last 18 months, I created more than 66 code repositories.
Some were client systems. Some were simulations, content pipelines, pitch tools, personal agents, property products, trading experiments, and ideas that should probably have stayed ideas.
Fewer than 20% shipped.
That number is the useful part of the story.
AI removed the starting penalty
Before the current generation of coding agents, most software ideas died before the first useful screen. The setup cost was too high. You needed the right framework, the right specialist, enough budget, and enough confidence that the idea deserved all of that effort.
AI changed the economics. I can move from a question to a working system quickly enough that experimentation is now rational.
I built a physically ambitious gold-mining simulation because the existing games annoyed me. I built agents to analyse presentations because pitch work was something I already understood. I built property tools because one client had a deep enough domain to make the data useful.
None of those projects required permission.
That is the equalising effect people keep talking about. It is real.
Building is not shipping
The dangerous conclusion is that because the first working version is easier, the whole job is easier.
It is not.
AI is very good at producing the moment where something appears to work. A page loads. A simulation moves. An agent returns an answer. The demo is convincing enough that your brain quietly marks the project as almost finished.
Then the actual work begins.
Mobile layouts break. Data models drift. Authentication fails on the one path you did not test. The agent confidently handles the common case and falls apart on a messy real input. Costs look trivial until the loop runs unattended. A feature that felt elegant in isolation makes the rest of the product harder to understand.
The prototype proves possibility. Shipping proves reliability.
The graveyard is still valuable
An unshipped repository is not automatically wasted work.
Several failed approaches taught me more than the version that eventually went live. My first large multi-agent system became expensive, adversarial, and almost impossible to debug. The useful result was not the system. It was a permanent suspicion of unnecessary orchestration.
Multiple attempts at rebuilding one client website became a live benchmark for AI capability. A year ago, agents repeated components, introduced magic numbers, ignored instructions, and rarely tested their own output. The same class of project is now possible with far less oversight.
The failures made that change visible.
The new constraint is judgement
When implementation gets cheaper, choosing becomes more important.
You need to know which idea deserves another week. You need to recognise when the architecture is becoming a hobby. You need to tell the difference between a rough edge worth fixing and a signal that the product should stop.
AI gives one person extraordinary leverage. It also gives one person enough rope to create 66 unfinished worlds.
The advantage does not belong to whoever can generate the most code. It belongs to whoever can decide what matters, cut what does not, and stay for the unglamorous last part.
That is the difference between building and shipping.