A fully automated growth loop is your biggest point of failure

The most advanced product teams are supposed to be the ones that need the fewest people in the room. That’s the quiet promise inside the phrase everyone’s chasing right now: the self-driving product. Point AI agents at your growth engine and they run the improvement cycle themselves, testing, tuning, and shipping around the clock, with no human waiting on the next iteration. The further you get, the more advanced you look. Fewer hands, deeper automation, more maturity.

Two terms there earn plain words, because the rest only lands if you have them. A growth loop is the engine under products that compound. Every new Substack writer brings in readers, and some of those readers start writing. The output feeds the input, so the thing grows itself instead of needing a fresh ad budget every quarter. A self-driving product is the newer idea, pushed hardest by the analytics company PostHog: let AI agents run the tuning of that loop, not just the product inside it. The team that gets there, the pitch goes, wins on infrastructure maturity, on how much of the machine can run without a person.

It’s a good pitch, and for two years it’s been mostly right. But “maturity” carries a second meaning that got buried under the first, and this month two findings dug it back out.

The maturity that counts is no longer how much of your loop the agent can run. It’s how well the loop keeps running the day that agent gets expensive, gets cut off, or quietly rots. Automate the whole thing with no hedge and you haven’t reached the frontier. You’ve concentrated your compounding engine onto a dependency whose price you don’t set and whose decay you can’t see.

Start with the price, because it moved first. Martin Fowler, one of software’s most-read voices on architecture, marks April 2026 as the month enterprise AI cost stopped being an engineering line item and became a CFO’s problem. He points to one company whose token spending climbed from $5M in August 2025 to $15M last May, on track for $120M a year. The driver wasn’t the coding agents. It was everyday staff turning PDFs into slides and drafting email, ordinary use that crossed from a few power users to nearly everyone. Fowler reports these figures from the field, so read them as a well-sourced account rather than an audited number. The direction is what matters: the compute your loop runs on is priced on a curve you don’t control, and the curve is still climbing.

There’s a partial escape, and it shows the trap clearly. Model providers now sell tiers by name, cheaper and blunter up to pricier and sharper. When the bill spikes, you can drop your agent to a cheaper tier. But a loop wired to run on the sharpest reasoning may simply not work on the cheap one. If you never built it to degrade, the cheaper tier isn’t a fallback. It’s an outage.

Then there’s the rot, which is worse because you can’t watch it happen. A study presented at the EASE 2026 software-engineering conference in Glasgow this June found something specific about AI-written code: teams extend it far more than they repair it. Human-authored code gets bug-fixed. AI-authored code gets more features piled on, because its failures don’t surface as broken tests. They surface as architectural incoherence, code that runs clean, passes every automated check, and quietly contradicts itself underneath. One analysis from GitClear and LeadDev put it at 1.7 times more total issues and 1.64 times more maintainability errors, though those ratios are reported rather than independently confirmed. The failure never trips an alarm. It waits until a refactor becomes a crisis.

Now put a self-driving loop in that picture. It is, by definition, a system that extends itself and no human repairs. It’s the exact case where coherence decay runs unchecked while every dashboard stays green. The deeper the agent runs your loop, the more of your core mechanic is quietly stacking up a debt nobody is reading.

And the dependency can vanish outright, not just get costly. In June, a U.S. export order flagged a capability in two Anthropic models, and the company switched both off for every customer within three days of launch. A team leaning on one of them got no notice and no transition window. Cost you can watch. Rot you might catch late. A revoked model is simply gone one morning.

The bullish read deserves a fair hearing, because it isn’t wrong. PostHog’s Ian Vanagas argues the durable advantage is exactly this infrastructure maturity, the capacity to let agents run the loop end to end, and the benchmarks behind it are real. Depth of automation is a genuine advantage when the thing you depend on is cheap, available, and sound. For most of the last two years it was all three. What changed this year is that none of the three is safe to assume anymore. The bullish case measured maturity on the one axis that just stopped being the binding one.

Because there are two axes here, and they move independently. One is depth: how much of the loop the agent automates. The other is survivability: how gracefully the loop keeps going when the agent’s price triples, its access is pulled, or its output decays. You can be high on one and flat on the other. A loop that scores maximal on depth and zero on survivability isn’t mature. It’s fragile in exact proportion to how far it got, because the team that automated the most of its core engine is the team with the most to lose from one vendor’s price sheet or one quarter of silent decay. Depth without a hedge measures one thing well: how concentrated your risk has become.

So the open question isn’t whether self-driving loops are hype. They’re real, and they compound. The question is what maturity should now mean, and there’s a clean way to find out. Take any team running a genuinely self-driving core loop and ask one thing: what happens the day token cost triples or the model gets embargoed? If the answer is “we throttle to a cheaper tier, a human takes the wheel, and the loop runs degraded but alive,” survivability was designed in and the depth was safe to chase. If the answer is “the loop is the product, and there’s no manual mode,” the self-driving product was quietly the most exposed thing on the roadmap, and everyone kept scoring it as the most advanced.

The proof will be a single artifact, and it doesn’t exist yet: a self-driving loop shipped with a tested manual mode, one somebody has actually run with the agent switched off. Whoever publishes that first will have shown the two kinds of maturity can be held at once. Until then, in your category, the most automated loop and the most fragile one may turn out to be the same loop.