Designing for the AI bust: why wrappers die and resilient products survive
AI spending is running far ahead of AI revenue. Whether that ends in a sharp correction or a slow squeeze, products built as a thin layer over someone else's model are the most exposed. They own neither the intelligence nor the data, and their supplier can copy them in a release.
This article is for product designers and product managers deciding what to build on top of AI. It covers why thin wrappers are fragile, what a resilient architecture looks like from the product side, and why governance belongs in the interface rather than in a policy PDF.
§ 01
The revenue gap behind the hype
In June 2024, Sequoia's David Cahn ran a simple calculation. Take Nvidia's data center revenue run rate, double it to cover the energy, buildings and other costs around the GPUs, then double it again to leave a 50% margin for whoever rents that compute out. The result was the revenue AI products would need to earn to justify the investment. His essay, AI's $600B question, summed it up in one line: "AI's $200B question is now AI's $600B question."
You don't need to predict a crash to take that seriously. A gap that size gets closed one of two ways. Revenue grows into it, or spending falls to meet it. In both cases the companies selling compute and models will push hard to capture more of the value themselves, and that pressure lands on the products built on top of them.
For a designer, that changes what "a good AI feature" means. A feature that only works while model access is cheap and the vendor ignores your niche is a feature with a countdown on it.
§ 02
Why thin wrappers are fragile
A thin wrapper is an interface over a general model API with little of its own underneath. "Chat with your PDF" was the classic example. It looked like a product until model providers added file uploads to their own apps.
Wrappers have two problems that design can't fix on its own. The first is subsumption. When the model provider ships your core feature as a checkbox, your differentiation disappears overnight. The second is margin. A wrapper buys intelligence at the provider's retail price and sells it on, so every price cut by a competitor comes straight out of its margin.
The products that hold up are the ones where the model is an engine, not the product. Vertical software for a specific job, like claims handling, dental scheduling or freight quoting, owns the workflow, the integrations and the data that accumulates as people use it. The model makes that software faster. It isn't the reason anyone pays for it.
The test I use is blunt. If the model provider released your main screen tomorrow, what would your users still need you for? If the answer is nothing, start designing the answer.
§ 03
Design for more than one model
Relying on one model vendor is a single point of failure. Prices change, models get deprecated, rate limits hit at the worst moment and outages happen. The architectural answer is a routing layer between your product and the models, and it's easier to adopt than it sounds. Routers like OpenRouter let you pass a list of models in priority order and fall back automatically when the first one errors, hits a rate limit or goes down, billing you for whichever model actually answered.
This is a product decision as much as an engineering one, because the user feels it. Design for it explicitly. Decide which tasks need your best model and which can run on a cheaper one. Decide what the interface shows when a slower fallback answers. Write the copy for "this is taking longer than usual" before you need it.
A fallback is only safe if you know it's good enough. Keep a small set of real tasks from your product, a few dozen is plenty to start, and run every candidate model against them before it goes on the list. Score the outputs the way your users would judge them, not on a public benchmark. When a vendor changes a model under the same name, run the set again. Without this, the routing layer quietly trades reliability for surprises, and users notice before you do.
Open-weight models add another option. Running a model inside a client's own environment answers the question enterprise buyers ask first: where does our data go? For some products that turns privacy from a sales objection into the reason they win the deal.
§ 04
Governance is part of the interface
Regulation is turning from talk into deadlines. Under the EU AI Act, providers of general-purpose models with systemic risk have obligations from 2 August 2025 under Article 55. They have to evaluate and adversarially test their models, assess and mitigate systemic risks, report serious incidents and protect their models with adequate cybersecurity.
Most product teams aren't model providers, but the pressure flows downstream. Buyers in hiring, lending, health and insurance now ask how a product reaches its decisions and who can override it. The answer lives in the interface. Human review steps for consequential decisions. Clear labels for what the model produced. Logs a customer's compliance team can read. A way to correct the system that sticks.
Treat these as features, not paperwork. A reviewer queue that's fast to work through is a design problem. So is an explanation panel that a loan officer actually reads. Teams that design these well will sell into regulated industries. Teams that bolt them on at the end will lose those deals.
§ 05
What the deployment phase rewards
The economist Carlota Perez describes technology revolutions in two halves. In the installation period, financial capital floods in, infrastructure gets overbuilt and a bubble often forms. After the turning point comes deployment, when the technology spreads through the wider economy and the useful products get built on infrastructure that's now cheap. Railways and the dot-com fiber build-out both followed that path.
If AI follows it too, the opportunity for designers grows rather than shrinks after a correction. Compute and model access get cheaper, and the winners are the products that turn that capacity into dependable work for a specific job.
So build for that world now. Here's the short version:
- Own something the model provider can't ship: a workflow, an integration or data that improves with use.
- Put a routing layer between your product and the models, and design the fallback states.
- Design review, override and explanation as first-class features in any flow that makes consequential decisions.
- Measure your AI features by the job they finish, not by the model they call.
None of this depends on guessing when or whether the market corrects. It's the product you'd want either way.