The window is closing faster than most people realise.
With AI, it has become alarmingly fast for anyone to look at an idea and replicate it — not just clone a simple app, but reconstruct an entire platform. We now have models you can describe a complex system to, and they will spend multiple hours building something that once took a team of humans multiple years. The implication is straightforward: whatever you are thinking of building, you should ship it now. The gap between conceiving an idea and someone else executing it has collapsed from years to days.
Very soon, I do not believe there will be any idea that is genuinely novel in its implementation. Every product will increasingly be some form of orchestrated assembly — a combination of open-source projects, foundational models, and available APIs, wired together to solve a specific problem. That is not a critique; it is simply the reality of what happens when all of human knowledge and every open-source project ever written becomes the raw material that any developer — or AI agent — can reach for at will. The synthesis of existing ideas, expressed in a new configuration, will be the default mode of innovation going forward. Original development at the machine level is behind us. We passed that point quietly, and most people have not yet registered it.
The Software Development Lifecycle as We Know It Is Dead
For decades, software development followed a well-worn path: requirements, architecture, development, testing, staging, deployment. Methods like Waterfall and Agile were designed to enforce a minimum level of stability — typically ensuring around 70% functional confidence before anything reached a user's hands. These processes existed because humans were slow, mistakes were expensive, and coordination overhead was enormous.
That calculus no longer applies.
We now have tools and practices that bypass entire phases of that lifecycle. Specifically, browser automation has made one of the most expensive and time-consuming phases — User Acceptance Testing — fully programmable. Previously, UAT required real users, structured sessions, written test cases, and weeks of feedback cycles. Today, we can write agents that navigate a live application exactly the way a user would, verify functionality against acceptance criteria, and report back with structured results — before the software has ever been touched by a human tester.
This is not a marginal improvement. This is a categorical shift. We can now have software whose core functionality has already been verified before it reaches even a QA engineer. The loop from concept to verified, working implementation now runs in hours, not months. People moving away from writing machine-level code and having code generate itself is not just a productivity story — it has collapsed the entire software development lifecycle into something almost unrecognisable from what it was five years ago.
If You Are Still Waiting for the Perfect Moment, I Have Bad News
I understand the instinct to hold an idea close until the timing is right — until the implementation is polished enough that it cannot be easily replicated, until you have figured out the moat, until everything is ready. I understand the fear of shipping something imperfect and watching someone else copy it, refine it, and beat you to market.
But here is the hard truth: as of today, there is no implementation that is entirely unreproducible. From consumer apps as ubiquitous as Notion to highly specialised systems used by defence contractors, every category of software is now within reach of a capable developer and a few AI agents working in parallel. We already saw a clear signal of this when a Google product manager fully vibecoded a working application that ended up being deployed by the US government and actively paid for at scale. If that single example does not illustrate the stakes, nothing will. The barrier between idea and execution — which was once the primary competitive moat in software — is gone.
The only protection that remains is being first. Not first to think of it. First to ship it.
The Urgency Is Real
If you are sitting on something you have not shipped yet, you have very little time left.
Not because your idea is bad. Not because you are not talented enough to execute it. But because the same tools available to you today are available to everyone today — and they are only getting faster and more capable.
Ship the imperfect version. Ship the minimum viable proof. Ship the thing that makes you slightly uncomfortable because it is not quite ready. The only version that cannot be copied is the one that already exists in the world, with real users, real feedback, and the head start that only comes from having moved first.
The window is not closed yet.
But it is closing.