Let's be frank.

The current excitement around setting up your workflows and loops — it's not new. We have always worked in loops. Learning loops. Development loops. Ideate, build, learn, adapt. We just did it in steps, with different people responsible for different parts of it.

User research would spend time collecting insights. Then you'd spend just as long bargaining with the PM or design lead on how to actually incorporate any of it. Then you'd try to get traction with engineering, get it prioritized, get it shipped — and then start over. Or QA. Or engineering constantly testing, validating, trying to improve what already is.

That's a loop. It was always a loop. It was just slow, and leaky, and the handoffs killed half the learning before it went anywhere.

So when I read "I will code loops" as the new big innovation

It makes me question fundamentals.

Because since day one I've heard the same question from people building with AI: how do I make sure the agent I build learns from the changes I make? How do I make sure it takes new information into consideration without me having to tell it every time?

Those are not technical questions. Or — they're not only technical questions. They're organizational learning questions. And there's a whole field that has been working on them for decades.

Back when I was studying, people would ask me: what am I actually going to use this for? Organizational learning theory. Knowledge theory. Trust theory. Team psychology. It felt abstract. Disconnected from real work.

It doesn't feel abstract anymore.

What it actually takes for something to learn

This is what I keep coming back to. Not: how do you chain agents together. But: what does a system actually need in order to learn? Not just repeat. Not just iterate. Learn — meaning it gets better, it accumulates something real, and it doesn't reset the moment conditions change.

Argyris and Schön called the difference single-loop versus double-loop learning. Single-loop: you detect an error and correct it. Double-loop: you detect the error, then question whether the underlying assumptions were right in the first place. Most AI workflows right now are single-loop systems dressed up as double-loop.

And the things that break it are the same things that have always broken organizational learning:

You can't write down everything that matters. Some of what makes your process good is tacit — it's judgment, context, professional intuition. AI systems eat explicit information fine. Tacit knowledge is harder. If you don't have a way to surface and encode what's implicit, your loop learns the wrong things.

Trust collapses when you can't explain why. A process that adapts without you understanding why it adapted will eventually produce an output you can't stand behind. Human organizations solved this through transparency, communication rituals, governance structures. AI systems need the same things — we're just not building them yet.

You can't absorb what you don't already partly understand. Cohen and Levinthal showed this with organizations. You can't drop a new strategy document on a team that doesn't understand the domain and expect them to integrate it. Same is true for your agents. How you architect context isn't a technical detail. It's organizational design.

What this forces you to understand

And here's the part I find genuinely interesting — not anxiety-inducing, but interesting.

All of this forces me — forces everyone — to get clearer on what we actually need to thrive. What needs to be in place for a process to learn. What you monitor. How you guide. What you trust and what you stay responsible for. How your skills and agents build trust over time. What the human mechanisms are that can't be offloaded.

It's forcing a much more honest conversation about what the important work actually is. The people. The connections. The judgment calls. The things that require you to be present.

The loops aren't new. Making them wise — that part is on us.