Boris Cherny, the guy who runs Claude Code at Anthropic, said something last week that made me stop scrolling. He mentioned that he does not prompt Claude anymore because he has loops running, so his job now is simply to write loops.
Peter Steinberger put it even more directly, arguing that you should not be prompting coding agents anymore, but rather designing the loops that prompt your agents.
And Addy Osmani, who leads Chrome engineering at Google, gave the whole thing a name: loop engineering.
If you have been heads-down building, this might be the first time you are hearing the term. But it is already the dominant workflow among the developers shipping the most AI-assisted code right now. Here is what it is, why it matters, and the one piece of the setup almost nobody is talking about yet.
For the past two years, working with a coding agent meant typing a prompt, reading the output, deciding what to do next, and typing another prompt. The agent was a tool and you were holding it the entire time.
Loop engineering flips that. Instead of you prompting the agent turn by turn, you design a small system that finds the work, distributes it to agents, checks the output, records what got done, and decides what to do next. You wake up to results.
Osmani breaks it down into five pieces plus one persistent state layer:
All the major platforms now ship some version of these primitives. Claude Code has them, Codex has them, and while the names differ slightly, the capability is exactly the same. Once you see the shape, you stop arguing about which tool to use and just design loops that work regardless of where you happen to be sitting.
Here is what struck me reading Osmani’s breakdown: every one of these six pieces involves you communicating with agents. You are writing automations, writing skills, writing prompts, reviewing output, and giving feedback.
And almost everyone is doing it by typing.
** Typing is the ultimate bottleneck. **Most people type at 40 to 60 words per minute, whereas you speak at 150. That is a massive difference in input bandwidth. But the real tax is not speed, it is friction. When you have to switch from thinking to typing, you edit as you go. You truncate. You write shorter, less complete prompts because typing full context feels like a chore.
This is exactly why developers give AI agents thin, underspecified instructions and then wonder why the output feels shallow. The agent isn’t bad at reasoning. You just gave it a tweet-length prompt when what you actually needed was a paragraph of context.
I have been using DictaFlow to talk to my agents instead of typing to them. It sounds like a small change, but it changes the dynamic entirely.
Instead of typing “fix the login bug in auth.ts” and hoping the agent figures out which bug and which edge case, I speak. I say that the login flow in auth.ts throws a 500 error when the session token expires mid-request, so we need a retry with a fresh token before failing. I also tell it to check the error boundary in the React component because right now it shows a white screen instead of redirecting to login.
That took eight seconds to say. Typing it would have taken two minutes, and honestly, I would have stopped after the first sentence.
When I am reviewing agent output, I usually dictate my feedback while scrolling through the diff. Comments that would have been a simple “looks good” turn into actual observations, because speaking a full thought is fast enough that I don’t skip it.
When I am writing a skill file, which are those codified project knowledge docs agents load, I dictate the structure, the rules, and the conventions. The output is richer because the input was richer. I described what I actually wanted instead of what I had the patience to type.
The setup is straightforward. DictaFlow runs on Mac, Windows, and iOS, so it works wherever your development environment lives. It uses a hold-to-talk trigger where you hold a key, speak, release, and your words appear in whatever field your cursor is in. There is no copy-paste and no switching windows.
Here is the workflow I landed on:
The throughline is the same in every case: you give your agents richer input. The loops get smarter because the instructions got better, not because the model changed, but because you stopped truncating your thoughts.
Loop engineering is real, and it is going to separate the developers who get massive leverage from AI agents from the ones still prompting one turn at a time. But the quality of your loops depends entirely on the quality of what you feed into them. If you are still bottlenecked at 40 words per minute of typing, your loops will reflect that.
Loop Engineering in 2026: Why the Best Developers Don’t Prompt AI Agents Anymore : They Design… was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.