Every few weeks the AI crowd discovers something engineers have known for thirty years, slaps a new name on it, and acts like they invented fire. The latest one is „design AI agent loops instead of prompt engineering.“ Peter Steinberger said it. Boris Cherny said it. And suddenly the whole timeline lost its mind, like someone had just unsealed a forbidden scroll.
Here’s the part nobody wants to admit. This isn’t new. This is literally how good software has been built since before half of these „AI pros“ could write a for loop. They just gave it a cooler name and a screenshot.
The loop was always there. You just called it „your job.“
Let me ask you something. How does a real engineer build a feature? Not a tutorial engineer. A real one, the kind who’s shipped things that page you at 3 a.m.
They don’t sit down and type the whole app from top to bottom like they’re transcribing a dream. They start with what they’re trying to build. They define the interface. What goes in, what comes out, what happens when someone feeds it garbage. They write a test that describes the behavior they want. Then they implement just enough to make that test go green. Test fails? Fix the implementation, assuming the test itself is actually correct. Run it again. Green? Cool. Now write the next test. Does the old one still pass? Yes? Keep going. Are all the cases from the spec covered yet? No? Then you’re not done.
That’s the loop. That’s the entire thing.
It starts with the thing you want to build. What are the edge cases. What’s the input. What’s the expected output. From there you build the cycle that grinds the implementation against the spec until reality matches intent. Design the interface, implement it, test it, deploy it, then guard it with integration tests and end-to-end checks. Manual testing? Sure, sometimes. But let’s be honest, most of that manual clicking should’ve been automated years ago. Playwright on the frontend. A few clean tests on the backend. The „loop“ everyone’s losing their mind over is just the software development lifecycle wearing a trench coat.
So when someone tells me agent loops are a revolutionary new paradigm, I want to gently hand them a copy of Kent Beck’s TDD book from 2002 and ask them to read the dedication.
What actually changed (and it’s not nothing)
Okay, I’m not here to be the old man yelling at the cloud. Something real did change. Let me give you the honest version.
Before Sonnet 4, agents were basically toddlers with a keyboard. You couldn’t trust them with a task longer than a few minutes without babysitting every token. You’d ask for a feature and come back to find it had refactored your auth layer for fun and deleted a test because it „wasn’t passing.“ The dream of „go do this while I get coffee“ was a meme.
Sonnet 4 changed the math. For the first time, longer-running tasks actually worked. And the second that happened, everybody serious about this started asking the same question. How do I let an agent run without me hovering over its shoulder?
The answer was the loop. Write the spec. Write the acceptance criteria. Let the agent do its own testing. On the frontend it can take a screenshot and check whether the thing it built actually looks right. On the backend you wire up Playwright for the UI components, or you figure out the integration story. Testcontainers? Spin up a throwaway Postgres? Hit a real preview environment? All of that goes into the AGENTS.md or the CLAUDE.md, and now the agent has a closed feedback loop it can run against without you in the chair.
Notice what that is. It’s not a prompting trick. It’s an engineering harness. The agent isn’t smart because you found magic words. It’s effective because you built the same scaffolding you’d build for a junior who you actually wanted to succeed.
The knowledge got un-gatekept, and that’s the actual story
Here’s the part I find genuinely wild, and it’s bigger than the loop itself.
The people I jokingly call the „vibe coders,“ the folks who never did the years of grinding, who never inherited a cursed legacy codebase or got destroyed in a code review by a staff engineer who’d seen it all, those people can now build software that’s reliable, maintainable, and reasonably secure. Not because they suddenly learned everything. Because the knowledge is baked into the model.
You can literally prompt Claude or GPT to design the loop for you. Ask it how serious teams built software before the AI wave. Ask it to research TDD, CI/CD, deployment patterns, and then design an agent loop based on all of it. And it’ll do a shockingly good job.
Think about what that actually means. This knowledge used to be gatekept behind a wall most people never climbed. You studied for years. You took the bad job to gain experience. You learned from people better than you, who were often too busy to teach. You read the books, you fought with the patterns, you got burned, you internalized the scar tissue. That was the toll. The accessibility of all of it just dropped to roughly zero, because it’s sitting inside the weights now, free for anyone who asks the right question.
That’s not a small thing. That’s the most democratizing shift in software I’ve seen in my career.
But don’t get high on your own supply
Now here’s where I push back on the hype, because the hype always overshoots.
You still have to be an expert to squeeze the maximum out of these models, but not in the way most people assume. Here’s the counterintuitive part the data actually shows. Junior developers tend to accept more of what the AI suggests, not less. GitHub’s own peer-reviewed study found the least-experienced developers accepted around 32% of Copilot’s suggestions versus about 26% for the most experienced. A field experiment on Ant Group’s CodeFuse found acceptance barely moved with seniority at all, hovering around 15 to 20% for everybody. And the raw productivity gains skew hard toward juniors too. That BIS field experiment clocked a 67% jump in code volume for junior staff, while the senior gains weren’t even statistically significant.
So if anything, the naive read of „acceptance rate equals skill“ is backwards. The senior signal shows up in a different number entirely. A 2025 Fastly survey found senior developers report shipping a much higher share of AI-generated code than juniors, roughly 32% versus 13% saying more than half their shipped code is AI. But, and this is the whole point, those same seniors also edit that AI output far more heavily before it goes out the door.
That’s the real story. Accepting a suggestion is easy. Knowing which suggestion to accept, what to rip out, and which edge case is going to blow up in production six months from now is the hard part, and that’s the part experience buys you. The model is an absurdly powerful tool, but it’s still a tool, and tools amplify whoever’s holding them. The junior accepts more and ships fast. The senior accepts selectively, rewrites half of it, and ships something that survives contact with real traffic. Hand a Formula 1 car to someone who just got their license and watch what happens.
That said, even the role of „expert“ is shifting under our feet. Prompt engineering used to be the differentiator. The person who knew the magic incantations won. But the models keep getting smaller, smarter, and capable of longer runs, and the magic-words advantage is evaporating. The new edge isn’t the prompt. It’s the loop. If your harness genuinely guarantees the quality of the output, the manual line-by-line review starts to feel less like a necessity and more like a security blanket. The verification moved from your eyeballs to your test suite, which is, again, exactly where it should’ve been the whole time.
The next hot take is already loading
So what’s the next thing the AI pros are going to „discover“? Let me make a prediction.
It’s deployment. Specifically, how do you ship software reliably without nuking the experience for the customers you already have.
And once again, it’s going to be a rediscovery of things real teams already do. You’re going to see the AI crowd suddenly get excited about dev environments, QA environments, and prod. They’re going to „invent“ A/B testing. Feature flags will trend. Canary deployments and cohort rollouts will get the breathless thread treatment, like nobody ever shipped to 1% of traffic before watching the dashboards.
Here’s the genuinely cool part though. Drop an agent inside that deployment loop and something new actually happens. It pushes to a small slice of production, watches the thing behave in a real setting with real traffic, confirms nothing’s on fire, and only then widens the rollout. The agent isn’t just writing the code anymore. It’s standing in the war room watching its own deploy and making the call. That’s the loop extended all the way to production, and it’s going to be the next thread that breaks containment.
So yeah. „Design agent loops, not prompts“ is a great tagline. It’s also just software engineering, the same way it’s always been, finally available to everyone instead of locked behind a decade of dues. The engineers who already lived this are nodding. Everyone else is about to learn why we did it this way the whole time.
Welcome to the loop. We’ve been here a while.