Author(s): Naresh Idiga

Originally published on Towards AI.

How to Build a Self-Improving Company with AI

Most founders are using AI wrong. They’re adding it on top of existing company structures. That’s the old model.

This article was written with the assistance of an AI writing program, based on the author’s notes and analysis of Tom Blomfield’s YC batch talk.

Tom Blomfield co-founded Monzo — took it from zero to 5M+ customers and $900M raised. Now he’s a General Partner at Y Combinator. In a recent batch talk, he made one core argument, built partly on ideas he borrowed from Jack Dorsey’s tweets and a talk by fellow YC partner Diana:

Most founders are using AI wrong. They’re adding it on top of existing company structures. That’s the old model.

The new model: your company is a set of recursive, self-improving AI loops.

Here’s the framework — and what it means for every developer, builder, and startup founder right now.

TL;DR

• Most companies bolt AI onto old hierarchies. Wrong model.
• The right model: recursive, self-improving AI loops that get better while you sleep.
• Key shifts: record everything → make your company legible to AI → burn tokens not headcount → cut middle management → keep humans at the edge.
• The constraint is shifting from headcount to token spend. The companies that win will maximize what AI can do, not how many people they employ.

Table of Contents

1. The Roman Legion Problem
2. The Self-Improving AI Loop — All 5 Layers
3. The Holy Shit Moment at YC
4. Real Examples: Product, Support, and Ops Loops
5. Four Things to Do Right Now
6. Where Humans Still Matter
7. What This Means for Developers and Builders

1. The Roman Legion Problem

Blomfield opened with a sharp analogy — one he credits to Jack Dorsey’s recent tweets.

The Roman legions were built to project power from Rome to the far edges of the empire through nested hierarchies: named individuals with fixed spans of control, passing orders down and sending information back up.

Most companies today are still organized like Roman legions. Humans are the conduit for information flowing up and down. That’s not a productivity problem. It’s a structural assumption baked into how we think about organizations.

And AI doesn’t just improve this structure — it breaks the assumption underneath it.

The old mental model: add AI co-pilots to your existing workflows. Make engineers 20% more productive. Ship more code. Blomfield’s critique: that’s like putting a more powerful engine onto a horse-drawn cart. You’re taking the old way of working and adding a more powerful engine onto it.

The new mental model: redesign what a company is.

2. The Self-Improving AI Loop — All 5 Layers

Instead of thinking about AI as a tool bolted onto your org, think about your company as a set of recursive, self-improving loops. Each loop has 5 layers. If every single step runs with minimal human intervention, your system gets better and better while you’re sleeping.

Here are all five layers:

Layer 1 — Sensor Layer This is where real-world data comes in. Emails from customers, support tickets, code changes, people cancelling their subscription, product telemetry. Think of it as the sensory layer that picks up signals from the outside world.

Layer 2 — Decision Layer (Policy Layer) This is where rules live. What can the system act on autonomously? What does it have to log? What must it ask a human permission for? This is the policy and decision layer — guardrails for what the AI can and cannot do on its own.

Layer 3 — Tool Layer This is where code executes. Deterministic APIs — query a database, look at a calendar, send an email, update a record. These are the tools the AI can call. Blomfield describes this as the “skills and code” layer — the actual mechanisms of execution.

Layer 4 — Quality Gate Before any action is committed, it passes through a quality gate. This might be eval checks, safety filters, or human review for high-risk actions. It’s the checkpoint between “the AI decided to do something” and “the thing actually happens.”

Layer 5 — Learning Mechanism This is what makes the whole thing self-improving. The system interacts with the real world, picks up where it didn’t work, and loops back to the top again. Failures become training signal. The loop tightens over time.

The key insight: if you can run every single step of that loop without human intervention — or with minimal human supervision — your system gets better and better overnight. Automatically.

3. The Holy Shit Moment at YC

Blomfield described exactly when this clicked for him at YC.

They built a simple internal agent — a tool their partners could ask questions like “when did I last have a meeting with this founder?” It worked well. Partners got answers faster. Useful, but nothing groundbreaking. Think of it as a smarter search bar for their internal database.

Then they put a monitoring agent on top of it.

This agent watched every query every YC employee made. It tracked when queries succeeded and when they failed. When they failed, it asked: Why? What would have made this work? Do we need different deterministic tools? A new database view? A different index?

Then — overnight — it wrote the fix, opened a pull request to the YC codebase, had another agent review it, and merged and deployed it. By the time a human came in the next morning to ask the same query, it worked.

No human involved.

“For me, that was like the holy shit moment. That’s not just AI making you 20 or 30% more valuable. It is the AI going through this loop to figure out how to self-improve.”

That’s the shift. Not a productivity gain. A system that detects its own failures and fixes them.

4. Real Examples: Product, Support, and Ops Loops

Blomfield didn’t stop at the YC internal example. He described how this same loop structure applies to every business function.

The self-optimizing product loop: Imagine an agent that goes through your product analytics to figure out which part of your sales funnel has the highest friction. It researches best practices, puts in place an A/B test, runs it for a week, picks the best-performing version, and deploys it. Then does that again and again and again. A self-optimizing product loop — running continuously, without a product manager needing to be involved in each cycle.

The automated customer support loop: Customer suggestions come in constantly. An AI “CPO/CTO” agent makes judgment calls: this suggestion doesn’t fit the roadmap, discard it. This one does — write the code, deploy it, ship it to the customer. No human involved in the decision, the build, or the delivery. The loop closes overnight.

These aren’t speculative. Blomfield was describing loops that exist or are being built right now inside YC companies.

5. Four Things to Do Right Now

1. Make your company legible to AI

If an interaction isn’t recorded, it doesn’t exist for your AI system. That means every email needs to be in a searchable database. Every Slack message. Every meeting recorded. Every decision logged.

YC took 2,000 hours of recorded office hours from the last 3 months and used AI to regenerate their entire user manual — a living document that now updates itself with every new piece of advice given. That’s what “legible to AI” means in practice.

Practical step: Audit your company. What information lives only in someone’s head, in a chat that expires, or in a meeting that was never recorded? That’s where you’re leaking intelligence.

2. Burn tokens, not headcount

The constraint is shifting. You will hit limits on token usage before you hit limits on hiring. The directional measure of a high-performing team member right now: how much are they actually using AI? Who is token-maxing?

Practical step: Before hiring for a function, ask whether that function could run as a well-designed AI loop with a human supervisor.

3. Eliminate middle management

Middle management exists to solve a coordination problem. AI solves that problem better and faster.

What remains: individual contributors (ICs) who build and operate, and a directly responsible individual (DRI) for every meaningful outcome. Blomfield: “I just don’t think you need middle management for this coordination problem. I think AI should be doing it.”

Practical step: Map your org chart. For every manager layer, ask: is this person primarily coordinating information flow? That’s a candidate for AI replacement.

4. Treat software as ephemeral, context as valuable

Models improve every few months. The dashboard you built six months ago? Regenerate it. The internal tool? Rewrite it with the latest model and better instructions.

What you should never throw away: the business context. The domain knowledge. The reasoning behind decisions. Blomfield: “The valuable part is the comprehension inside people’s heads of how the function works. The software on top of it is ephemeral.”

Practical step: Store everything as text — markdown, structured logs, plain-language runbooks. Your business knowledge should be model-agnostic and always ready to be fed into the next generation of AI.

6. Where Humans Still Matter

Blomfield is clear: humans don’t disappear. They move to the edge — where your intelligence system makes contact with reality.

That includes:

• Novel situations the models haven’t encountered before
• High-stakes, high-emotion moments — a founder thinking about breaking up with their co-founder, a difficult client negotiation
• Ethical judgment calls that require genuine moral reasoning
• Sales conversations — Blomfield says these remain human for the next 20 years

The company brain — all your data, emails, DMs, skills, and institutional knowledge — sits in the middle. Humans wrap around the outside, interfacing with the real world.

The Roman legion had humans everywhere. The AI-native company has AI everywhere in the middle, and humans precisely placed at the edges where it matters most.

7. What This Means for Developers and Builders

If you’re a developer, startup founder, or indie builder, this talk isn’t just interesting — it’s a forcing function.

The old valuable skill: writing code fast.

The new valuable skill: designing systems that improve themselves.

Old approach New approach Write code fast Design self-improving systems Add logging later Build with observability from day one Fix bugs when reported Failures feed back into the loop automatically Scale by hiring Scale by designing loops Ship and forget Ship and monitor the quality gate

The developers who win in the next 5 years won’t be the ones who prompt the most cleverly. They’ll be the ones who build companies and systems that learn.

Start with one loop. Pick one part of your product, ops, or content pipeline where you can close the feedback cycle — detect failure, analyze it, fix it, verify. Make that one loop self-improving.

Then do it again next week.

Blomfield ended with a question worth sitting with:

“If you were building your company today, would you start it in this shape?”

For most of you reading this — you’re small enough to build it right from the start. That’s the advantage.

Based on Tom Blomfield’s batch talk at Y Combinator. Watch the original (13 minutes): youtube.com/watch?v=t-G67yKAHBQ

This article was written with the assistance of an AI writing program.

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI