BLOG
Loop Engineering — An Engineer's Job Is Now 『Writing Loops』
『My job is to write loops.』From prompts to loop design. A look at the new wave where abstraction climbs from Prompt→Context→Harness→Loop, plus the real-world risks of cost blowups and comprehension debt.
At some point, an engineer’s job shifted from “writing code” to “designing the systems that make AI write code.” The latest form of this is Loop Engineering.
Instead of polishing a single prompt, you design the very “loop” that keeps an AI agent running autonomously along a time axis. All the engineer defines is the “goal” and the “stopping condition.” The details of implementation and correction get done by the AI itself, inside the loop. This way of thinking spread like wildfire in the first half of 2026.
The spark: “My job is to write loops”
What lit the fuse was a single remark from Boris Cherny, who leads the development of Claude Code at Anthropic.
My job is to write loops.
This statement from June 2026 captured, almost too perfectly, how an engineer’s role is shifting from “the person who types prompts one at a time” to “the person who designs the systems that drive AI autonomously.” That’s precisely why it spread across the industry so fast.
It rings true from a hands-on perspective, too. While you’re issuing instructions to an AI one question at a time, a human has to stay glued to the screen the whole time. That looks like “using AI,” but in reality it’s a state where the human is the bottleneck. Once you can design a loop, you can put AI to work even while you sleep. The order of magnitude of your leverage changes.
What is Loop Engineering?
Over the past few years, the way we engage with AI has climbed in abstraction like a staircase.
- Prompt Engineering — polishing a single instruction
- Context Engineering — designing the contextual information you hand to the AI
- Harness Engineering — designing the framework that runs the agent (tools, permissions, execution environment)
- Loop Engineering — designing that framework as a “loop” that runs autonomously along a time axis (we are here)
At the very bottom, Prompt Engineering was “one-off craftsmanship.” The higher you go, the more it becomes an “asset” that pays off repeatedly once designed. Loop Engineering sits at the summit, where the human doesn’t write out the concrete work procedure. All you write is the condition for “what counts as done.” After that, the agent reaches it by repeating trial and correction.
The 6 components that hold a loop together
An autonomous loop is, roughly speaking, made up of the following six parts. This is what Loop Engineering designs.
- Scheduling (Trigger) — when it kicks off. You set the launch condition with cron or a command like
/loop - Goal condition (Goal) — what has to be satisfied for it to stop. The termination condition that keeps the agent running until it’s achieved
- Isolated workspace (Isolation) — an environment where multiple agents can run at once without colliding. You separate workspaces with things like git worktree
- Verifier — a mechanism that checks the code the AI itself wrote, using different logic and a different model. The key is “don’t let the author grade their own work”
- Persistent memory (Memory) — carrying learned content across sessions. The memory that keeps you from redoing the same failure every time
- Connector — the interface for linking to external systems like GitHub or Slack so the loop can actually take action
Look at them in order and you’ll notice: not a single one of these is about how skillfully you prompt. What Loop Engineering tests is your sense for software design itself.
Practical tools, and an enthusiasm that has already begun
This concept isn’t just theory. An open-source CLI toolset called cobusgreyling/loop-engineering actually implements this way of thinking, and it has gathered over 4,800 stars in a short time since its release. It lets you assemble the six elements above from the command line — proof, I think, that Loop Engineering is moving from “buzzword” to “a tool you can touch.”
It’s not a silver bullet — 3 real-world risks
Read this far and it sounds like magic, but actually running it comes with clear costs. Adopt it without looking at these and you’ll get burned.
Cost blowups
The essence of a loop is that it “keeps running until it’s done.” Flip that around and it means if you get the stopping condition wrong, it will keep consuming tokens endlessly. It’s not rare to leave it running overnight and find that tens of thousands of yen melted away without you noticing. Designing “guardrails to stop the runaway (token ceilings, timeouts, cutoffs after consecutive failures)” is as important as the goal condition.
The responsibility to verify stays with humans
Even with a Verifier in the loop, that’s still just “a first-pass check by AI.” The responsibility for the decision to ship to production ultimately stays with the human, all the way to the end. Even if the loop reports “all tests green,” it’s meaningless if the AI wrote those tests loosely in the first place. Not trusting automated verification too much is, paradoxically, the trick to running loops safely.
The accumulation of comprehension debt
This is the quietest and scariest risk. Once humans stop reading the code the AI generates, the big picture of the system stops living in anyone’s head. A “loss of comprehension” you can’t repay later piles up.
Technical debt can be repaid by rewriting, but comprehension debt is a state where “you don’t even know what to fix or how.” When an incident strikes in the dead of night and no one can explain the internals of your own company’s code — that could turn into a trade where the time you gained from the loop’s productivity is clawed back later, all at once, with interest.
Conclusion — Designing the loop is still a human’s job
Loop Engineering is not “something that makes engineers unnecessary.” It’s something that raises where humans apply their leverage up one level — from prompts to “the design of the autonomous system (the loop) itself.”
Automation you don’t know how to stop is just a runaway, and productivity you don’t understand is just borrowing debt against the future. That is exactly why the value of people who can design the goal, the stopping condition, the verification, and the line of “how far to leave to AI and where humans read” will, if anything, keep rising.
At Wired & Eco, Inc., we provide design and adoption support for development workflows built around Claude Code and agents. We take on consultations such as “we’re having AI write code, but review and operations can’t keep up” or “we want to build a system that runs autonomous loops safely.” Please feel free to get in touch.