AI Loops Are Real — and They’re About to Change How You Think About Coding

The Paradigm Shift Nobody’s Ready For

I’ve been writing code for over a decade. I remember when autocomplete was a luxury. Then came Copilot. Then agents that could write entire functions. Now I’m watching Boris Cherny — the creator of Claude Code — say something that made me put down my coffee.

He doesn’t write code anymore. Not a single line.

At Meta’s @Scale conference last week, Cherny dropped a statement that should make every developer pause: “Two years ago, we wrote source code by hand. We started to transition so agents write the code. And now we’re transitioning to the point where agents are prompting agents that then write the code.”

He called them loops. And he’s betting they’re the next big thing.

What Exactly Is an AI Loop?

If you’ve used Claude Code or any coding agent, you know the drill: you give it a task, it works on it, it comes back with a result. You review, iterate, repeat. That’s the standard agent workflow — discrete, inspectable, controllable.

A loop is different. You don’t give it one task. You authorize a swarm of agents to run continuously in the background. No stop time. No end condition. They just keep working — forever.

Cherny’s own setup at Anthropic is both fascinating and slightly terrifying. He has one agent continuously scanning for ways to improve code architecture. Another hunts for duplicated abstractions that can be unified. Both submit pull requests like any developer would. Both never stop running. This is the natural evolution of what we’ve been seeing with multi-agent orchestration approaches — except now the agents aren’t just collaborating on one task, they’re running indefinitely.

The logic is simple: code is always changing, so why would the agents that improve it ever stop?

Technically, this borrows from classic computer science — recursive functions that call themselves. The difference is the stop condition. In traditional recursion, you have a deterministic endpoint: “stop when the array is empty” or “stop when depth equals zero.” In AI loops, a subagent decides when enough is enough. That’s non-deterministic. That’s the leap.

The Guy Who Stopped Writing Code

Boris Cherny’s story is worth understanding because it explains why loops matter. He’s not some AI hype merchant. He’s a self-taught programmer with an Economics degree who became a Meta IC8 Principal Engineer — one of the highest individual contributor ranks at the company. He led Instagram’s migration to Hack. He oversaw code quality across Meta’s entire portfolio. Then he joined Anthropic Labs in September 2024 and built Claude Code, which he calls an “accidental product.”

By 2026, his daily workflow looks nothing like a developer’s. His primary workstation is a phone. He maintains 5 to 10 active sessions with hundreds of sub-agents running concurrently. Overnight, thousands of agents execute deep-layer tasks. His record is 150 pull requests in a single day, submitted entirely from a mobile device.

When someone at the @Scale conference asked him point-blank — “Are loops the next hype cycle, or are they for real?” — he didn’t hesitate. “Yes, they’re for real.”

Coding, he says, is solved — at least for his stack. TypeScript and React? 100 percent. The broader ecosystem? Maybe 50 percent, and climbing with every new model release.

The Ralph Loop and Hill-Climbing

There’s a practical hack making loops viable today, and it has a name straight out of The Simpsons: the Ralph Loop. Named after Ralph Wiggum, it’s a dead-simple mechanism. The agent sums up everything it’s done so far, then asks itself: “Is the goal accomplished?” If not, it keeps going. If yes, it stops.

It sounds almost too basic to work. But it does — because it prevents the most common failure mode in long-running AI tasks: the model losing track of what it was doing. The Ralph Loop acts as a bounce-back mechanism, a reality check that keeps the agent oriented.

This pairs well with what AI researchers call hill-climbing. OpenAI’s Noam Brown recently observed that contemporary models can solve almost any problem if you throw enough compute at them. The idea is simple: keep making small, incremental improvements toward a quality threshold. Each iteration gets a little better. Over enough cycles, the gains compound into something substantial.

Codebase improvement is the perfect hill-climbing problem. There’s always a function that could be cleaner, a test that could be faster, an abstraction that could be simpler. A human developer picks a few things and moves on. A loop never moves on.

Here’s Where I Get Nervous

I manage an ICT division for a Philippine government institution. I think about systems, security, and cost every single day. And the loop paradigm raises three problems that don’t have clean answers yet.

First: the money. TechCrunch put it bluntly — “If that sounds expensive, it should.” Loops burn through tokens far faster than Q&A chatbots or even discrete agent tasks. There’s no ceiling on spending because the agents never stop. I’ve written before about the AI cost problem — the uncomfortable reality that someone is subsidizing your coding assistant. Loops take that math and crank it to eleven. The economics only work if the output is genuinely worth the burn rate, and for most teams outside Silicon Valley, that calculation doesn’t pencil out yet.

Second: trust. Standard agentic AI is manageable. You set clear goals, you check discrete units of progress, you stay in control. Loops flip that entirely. You’re authorizing a swarm of agents to work continuously with no predetermined endpoint. That’s not a tool anymore. That’s delegated authority. If one of those agents goes off the rails — submits a PR that breaks the build at 3 AM, or modifies a database schema based on a misunderstanding — you might not notice until morning. By then, other agents may have built on top of the mistake.

And it’s not a theoretical concern. We’ve already seen agentjacking attacks that trick coding agents into running malicious code. Now imagine that attack surface multiplied by a hundred, with agents running continuously and autonomously, each one a potential entry point. I wrote about why AI systems aren’t your friends — and loops make that point even sharper. These aren’t teammates you can trust with a gut check. They’re stochastic systems running on statistical patterns.

Third: what happens to expertise? This is the chess player in me talking. When you stop writing code, you stop exercising the muscles that make you good at it. Cherny is comfortable with that tradeoff — he’s now a system orchestrator, managing parallel agent loops instead of syntax. But I wonder about the developers five years into their careers who’ve never debugged a production outage without an AI copilot. When the loops fail — and they will — who fixes them?

The Other Side of the Argument

I’d be lying if I said there’s nothing compelling here. Cherny’s vision of democratization is genuinely exciting. At Anthropic Labs, PMs, designers, data scientists, and finance personnel all write code through agents. The person who builds the best accounting software, Cherny argues, will be an accountant — not a software engineer. The domain expert becomes the builder.

And the MCP protocol — Model Context Protocol — is the bridge. Standardized connectors for Salesforce, Google Docs, calendars, Slack. When an agent hits ambiguity, it autonomously messages another employee’s agent to resolve the dependency. Agent-to-agent communication. That’s not science fiction; that’s running internally at Anthropic right now.

There’s also the “harness decay” concept that resonates with something I’ve noticed myself. The product wrappers we build around AI models — guardrails, routing logic, error handling, human-in-the-loop permissions — exist because models aren’t good enough yet. But every model generation cannibalizes a chunk of that wrapper. Cherny predicts Claude Code’s product layer could shrink to 100 lines of code within a year. The model’s reasoning replaces the scaffolding.

So Are Loops Real or Hype?

I think they’re real — but not in the way the hype suggests.

Loops won’t replace developers next year. The cost alone makes that impossible for most teams, especially outside Silicon Valley budgets. The trust problem is even bigger. No organization I know of — certainly not a government institution — is going to authorize an endlessly running AI swarm with write access to production systems. Not without years of proven reliability.

But the direction is clear. We’re moving from writing code → supervising agents → designing systems where agents supervise other agents. Each step shifts the developer’s role further from syntax generator toward system orchestrator. The loop paradigm is the logical endpoint of that trajectory, even if practical adoption takes five years instead of five months. It’s the same fundamental shift we’re seeing with projects like Bezos’s Prometheus, which is betting $12 billion on artificial general engineers. The endgame is the same — AI that doesn’t just assist engineers but operates as one.

What worries me isn’t the technology. It’s the gap between what’s possible and what people are ready for. At the same conference where Cherny was explaining loops, the first audience question was a skeptical “hype or real?” That tells you something. Even the people who showed up to hear about AI development aren’t sure they believe it.

The most honest thing Cherny said wasn’t about loops at all. It was about legacy code. When asked about esoteric stacks his agents can’t handle yet, his answer was simple: “Wait for the next model.”

That’s the part that keeps me up. Not what AI can do today — but the quiet confidence that tomorrow’s model will handle what today’s can’t. Historically speaking, that confidence has been justified. The trend line points one way.

So here’s my take: loops are real, but they’re not for everyone. If you’re building greenfield TypeScript at a well-funded startup, you should probably be experimenting with them now. If you’re maintaining a 15-year-old government ERP system in COBOL — maybe wait for that next model. Or the one after that.

Either way, keep your eyes open. The loop paradigm isn’t about whether you want agents prompting agents. It’s about whether you’re ready for a world where that’s the default.