The New Moat Is the Inner Loop

Software used to be a thing you shipped.

Now it is becoming a thing that learns.

For the last twenty years, the best software companies built platforms. I saw this up close as a developer in my 20s at Microsoft on SQL Server, one of the platforms that became embedded in how enterprises store, query, and operate data.

For the next twenty years, the best companies will build recursive systems: products that observe their own use, score their own outcomes, and improve their own future behavior.

That changes what a moat means.

In the old world, a software company’s moat came from code, distribution, high switching costs, user experience, data, or brand. Those advantages still matter. But the code itself is becoming less defensible because intelligence is becoming a commodity.

GitHub, Anthropic, and OpenAI coding agents can read repositories, change files, run tests, and prepare pull requests.

This does not mean software is easy.

It means the scarce part is changing.

If many companies can access reasoning, code generation, summarization, translation, design, search, and workflow automation, then simply saying “we use AI” is not a moat.

The new question is:

Does the system get smarter every time it is used?

That is the real moat.

From Tools to Loops

Old software was mostly deterministic. Users clicked buttons. The software executed workflows. Engineers watched logs, read tickets, built features, and shipped updates.

New software is adaptive. Users interact. The system observes. It scores outcomes. It changes recommendations, routing, behavior, or workflows. The next interaction is shaped by the last one.

The most valuable software products are no longer just tools. They are learning machines with users inside the loop.

At the conceptual level, the loop is simple:

proprietary context → action → measurement → learning → better future action

The visible product can often be copied. The inner loop is harder to copy because it contains accumulated behavior, private context, operational history, judgment, and measurement.

Static software is shipped.

Living software compounds through use.

The Inner Loop

A recursive software system needs five things: a high-frequency action surface, a scoring function, a learning mechanism, a deployment path, and a compounding data advantage.

The action surface creates the raw material: searches, videos watched, payments processed, miles driven, incidents investigated, pull requests opened, trades simulated, or customers served.

The scoring function tells the system what mattered. The learning mechanism converts those scores into better behavior. The deployment path pushes improvement back into the product. The data advantage closes the loop: more usage creates better outcomes, better outcomes create more usage, and more usage creates more data.

That is the moat.

Not the static interface.

Not the first version of the model.

Not the claim that the company “uses AI.”

The moat is the private cycle of use, judgment, action, measurement, and improvement.

The Pattern in the Wild

Google Search was the early template. Google’s moat was not PageRank alone. It was the recursive loop between queries, results, user behavior, web crawling, ranking models, and distribution. The product looked like a search box. The moat was the system behind it.

Recommendation systems made the pattern more obvious. TikTok’s recommender systems rank eligible content based on predictions of what a user is likely to be interested in, including interaction patterns from people with similar interests.

The app is not just serving content. It is training a personalized model of desire. The user is not only consuming the product. The user is also teaching the product what to become.

Tesla shows the same idea in the physical world. Its neural networks learn from complicated and diverse scenarios iteratively sourced from a fleet of millions of vehicles in real time. The car is deployed into the world. The world produces edge cases. The edge cases improve how the car drives.

Again, the principle is the same:

context → action → measurement → learning → better future action

Coding Agents and the Private Loop

The newest version of this pattern is inside software teams themselves.

AI coding agents make code generation more available. But that alone is not the durable advantage. Everyone will have agents that can write code, refactor files, run tests, and prepare pull requests.

The advantage is the private loop around the agent.

A coding agent operating on a public benchmark is useful. A coding agent operating inside years of private repo history, test failures, production incidents, design rules, customer pain, code review feedback, and deployment outcomes is different.

You can rent the model, but the loop is owned.

The Objective Function Problem

Recursive improvement is only as good as the objective function.

A system that optimizes the wrong score becomes recursively worse.

Engagement loops can optimize for addiction or outrage. Trading systems can overfit. Coding agents can reinforce bad architecture if the tests are weak. Customer support systems can optimize for short resolution time while making customers feel unheard.

This is why the scoring function is not a detail. It is the strategy.

The loop compounds whatever it is told to compound.

That is why judgment still matters.

The future does not belong to systems that learn blindly. It belongs to systems with the right constraints, the right measurement, and the discipline to separate signal from noise.

Runtime and the Live Loop

Runtime itself means the moment code becomes behavior.

That is also where the moat now lives: not in the static code, but in the live loop where systems act, measure, adapt, and compound.

This is true for software companies. It is true for AI infrastructure. It is true for operational systems. It is true for portfolio engineering.

The durable advantage is not one model, one feature, one interface, or one forecast. Those can be copied, rented, or surpassed.

The durable advantage is the inner loop:

private context → disciplined action → measured outcome → improved future behavior

That is where compounding lives.

When intelligence becomes cheap, software becomes easier to copy. The scarce asset is no longer code by itself. It is the recursive system around the code: the private cycle of data, judgment, action, measurement, and improvement.

The future belongs to companies whose products have this recursive self-improvement loop. This inner loop is also one of the core design architectures behind Runtime.

Engineered compounding,
Deniz Erkan