If you build AI apps, invest in them, or keep wondering “is this a company or just a feature” — here’s the sharpest sieve there is: if the model company shipped your core feature natively, for free, tomorrow, what would you have left?

“Most prospectors went broke; the people selling shovels got rich” — this metaphor gets quoted a thousand times in AI, always ending in: don’t build apps, build infrastructure. That conclusion is lazy. The upstream “shovel” end (compute, power) does make money, but the entry fee is trillions in capital — not a founder’s battlefield. Meanwhile apps and distribution are a profit pool that’s fully real and deepening. On the prospecting end, there is real gold.

So the real question of the application layer is never “should you prospect” — it’s “among the prospectors, who survives?”

The Nine That Die: The Three-Sided Squeeze on Thin Wrappers

Start with the nine in ten that die. They share one shape: their core value is roughly “we called a good model + wrote a good prompt + built a clean UI.” This kind of app — a thin wrapper — is exposed to fire from three directions at once:

• From above, natively integrated by the model company. You prove a use case has demand; the model company builds it into its own product and ships it free as a native feature. The market validation you paid for becomes its roadmap.
• From below, flattened by open source and deflation. Your capability is rented from the model, and model capability is matched by open source month by month and priced down by deflation. The effect you’re proud of is free in open source next year.
• From the side, routed away by the aggregator. You don’t own the user’s intent entry — the OS, the super-app, the vertical-agent platform does. It can absorb you into a callable tool anytime, or just route to a cheaper substitute.

What the three have in common: they all attack “thin.” A thin wrapper holds nothing these three can’t take — capability is rented, users are borrowed, demand validation is done on someone else’s behalf. Nine in ten AI apps die not because they’re bad, but because they’re thin.

The One That Survives: Four Kinds of “Thickness,” None From the Model Itself

“Thick” means you own something, outside the model, that the model company won’t build and can’t copy. The application layer’s thickness has exactly four sources — a checklist you can take straight into diligence:

1. Proprietary data + a right/wrong feedback loop: your scenario continuously produces data nobody else can get, with a free referee built in, so the product improves with use.
2. Deep workflow embedding + accumulated context: you’re not a feature that gets opened, you’re a thing welded into a production process with three years of org context and permissions. Uninstalling you means re-architecting the workflow, not canceling a subscription.
3. Compliance, trust, and industry barriers: in healthcare, finance, law, can use ≠ dare use. Liability, audit trails, certification — general capability can’t vault that wall; vaulting it takes acquisition, certification, and time. Slow and expensive.
4. Complex systems integration: a real process embeds the model into a machine of dozens of systems, rules, exception handling, and human handoffs. Integration depth is itself the barrier.

Note that none of these four comes from “the model itself.” The application layer’s moat was never how strong your model is — it’s what you grew around the model.

A Sieve: Native Support, and What You Have Left

Compress that into one operable test:

Suppose the model company ships your core feature natively, for free, tomorrow. What do you have left?

Left with a deeply embedded workflow, three years of org context, a data loop nobody else can get, an unscalable compliance wall — you’re a company, and the native feature becomes your free upstream. Left with nothing but “better prompts, smoother UI” — you’re a feature, the one on someone’s roadmap that gets crossed off any day.

This sieve predicts three-year survival better than any “is it smart, is it growing fast.” Fast growth is itself a trap signal: the app growing fastest, most beautifully proving a demand, with the thinnest moat, is in the most danger — it’s using its own growth to do the model company’s free market research. Once demand is proven big enough, native integration arrives to harvest it.

Three closing lines. One: run that sieve on every AI app — “native support, what’s left” — and only what’s left is the real valuation anchor; prompts and UI don’t count. Two: re-label “fast growth, thin moat” as high-risk, not high-growth. Three: the application layer has its own “shovel” business (eval, orchestration, guardrails, memory infra) — higher certainty, lower ceiling — but it answers the same question: native support tomorrow, what’s left?

The AI app you’re building or backing — is it a company, or a to-do item not yet crossed off? Comments open.

Sources (framework argument, June 2026): the four thickness sources map to the moat criteria in Chapters 6 (workflow lock-in), 7 (data loop), 8 (intent routing), 9 (agent economics); intelligence deflation and open-source catch-up in Chapters 1 & 6 (Stanford AI Index, SemiAnalysis).

— From Chapter 10 of a book in progress, working title The Deflation Sandwich

#AI #AIApps #DeflationSandwich