Making things is no longer the hard part. Checking whether what you made will blow up in your face, that's the hard part. And almost nobody has built the systems to do it.
The Thoughtworks Future of Software Development report buried it in a bullet point but it's the most important sentence in the document: code generation is no longer the bottleneck. Verification is. They're watching senior engineers spend their days not writing code but figuring out whether the code an AI wrote is actually trustworthy enough to ship. That's the new job. That's where the expensive hours go.
Now stretch that same logic across every domain, because it applies everywhere.
Streaming platforms are collapsing their category walls because AI makes content creation so cheap and fast that the old competitive advantage, owning a format, dissolves overnight. Spotify can be a video platform. Netflix can be a music platform. The creation side got commoditized. What matters now is curation and trust: will this recommendation waste our time, or not? Every algorithm is a verification system. The ones that earn trust survive.
Eleven million people marked interest in a virtual Roblox concert before it happened. That's not a novelty number. That's a signal that an artist can spin up a distribution channel for live performance inside a game engine, at a fraction of the cost of a physical venue, and reach an audience most label executives haven't even considered yet. The making part, a virtual concert, is trivially easy now. The hard part is verifying whether the experience will actually hold up when millions of people show up at once, technically and emotionally.
And then there's the version of this story that should scare you if you're running any software product. The React2Shell vulnerability hit a CVSS score of 10.0, the highest possible severity rating, by exploiting the very mechanism React Server Components use to stream interactive UIs. The Flight protocol, which makes all that snappy server-driven rendering possible, turned out to be a deserialization sink that attackers can walk right through. The feature worked. The feature was fast. Nobody verified what it was doing to the attack surface. That's the pattern. Ship the capability, skip the audit.
Here's the thread: across software development, entertainment, finance, and infrastructure, we are living in a generation of outputs that far outpace our ability to inspect them. The AI economy needs to generate enormous revenues fast to justify the capital already deployed, and that pressure flows downstream to every company plugging in AI tools and shipping faster than they ever have. The incentive structure rewards output. Nobody is putting budget into verification.
We see this in our own engagements constantly. A founder comes to us with a product that "works." The features ship. The demos are smooth. But there's no harness around any of it. No way to know if the AI-generated code paths have security holes. No way to know if the recommendation logic is surfacing garbage that will quietly destroy retention. No staging environment that resembles production under load. The Thoughtworks report has a name for the skill that fills this gap: harness engineering. It's emerging as its own discipline because the need is real and the supply of people who can do it is almost nonexistent.
The apprenticeship crisis the same report flags makes this worse. Junior developers used to learn verification habits by sitting next to senior engineers and watching them tear apart their own code. That transfer of instinct doesn't happen when a model generates the code in fifteen seconds and the junior developer is just the person who hit enter. The muscle never develops. So organizations are accumulating outputs nobody on the team actually understands, and calling it speed.
This is not an argument against moving fast. We are not interested in slowing anyone down. But there is a version of fast that compounds and a version that quietly builds a debt you cannot pay. The executive who hears "we can ship twice as fast with AI" and nods approvingly is hearing only half the sentence. The other half is "and we'll need a new class of engineer whose entire job is making sure it doesn't catch fire."
What this means for you practically:
- If you're using AI-generated code in production and nobody on your team is specifically responsible for auditing it, you have a liability, not a feature.
- If your product is scaling into new channels, virtual events, streaming, platform integrations, and your infrastructure testing hasn't kept pace, the audience showing up will find the holes before you do.
- If you're buying into the idea that AI speeds up your entire operation, check whether you're also speeding up the mistakes and just shipping them faster to more people.
The moat in this era is not who can make things the fastest. It's who can tell the difference between what's good and what's going to fail before the customer does. Verification isn't a process. It's the product.
Whoever figures that out first, in music, in health, in any vertical where trust is the actual thing being sold, wins the next five years. Everyone else is just shipping faster toward the same wall.