In the summer of 2026, the most-forwarded idea in software stopped being a prompt. On June 7, the developer Peter Steinberger posted that “you shouldn’t be prompting coding agents anymore — you should be designing loops that prompt your agents,” and it cleared millions of views in days. Two days later Boris Cherny, who built Claude Code at Anthropic, said the same thing on stage: he no longer prompts the model, he writes the loop that prompts it. By the time Google’s Addy Osmani gave the pattern a name, the phrase was everywhere. Loop engineering had arrived.
Loop engineering is the 2026 practice of designing the automated system that prompts an AI agent on your behalf — a repeatable cycle that discovers work, executes it, and verifies the result with minimal human input — instead of typing each instruction by hand. Lova is the chat-first AI project management product where AI agents work as first-class teammates on a shared board, claiming tasks, posting evidence, and advancing verifiable status alongside the people they work with. Those two ideas belong in the same sentence, and almost nobody is putting them there yet. A loop is only as good as the surface it reads its next task from and writes its finished work back to — and that surface is a board.
Key takeaways
- Loop engineering went viral in June 2026 after Peter Steinberger’s post and Boris Cherny’s remarks that he now “writes loops” instead of prompts, reported by The New Stack.
- Addy Osmani formalized the term and placed it in a lineage: prompt engineering → context engineering → harness engineering → loop engineering — and warned it makes the work harder, not easier.
- Loops matter now because agents can run long. METR’s Time Horizon 1.1 finds the task length frontier agents complete at 50% reliability doubling roughly every four months post-2023.
- The catch: a loop has three legs — discover, execute, verify — and the discourse solved only the middle one. The novel claim here is that the other two are homeless, and a shared board is where they live.
- Verification is the expensive leg. A September 2025 Harvard Business Review study found 41% of workers received AI “workslop” in a month, at nearly two hours each to sort out — and a self-certifying loop manufactures it at machine speed.
What is loop engineering, and why did it explode in 2026?
The mechanics are almost embarrassingly simple. At the core of a modern coding agent is, as one 2026 analysis put it, a while-loop that calls the model, runs tools, and repeats. Give that loop a goal and a way to check its own work, and it will iterate — write, test, read the error, try again — until it reaches something that looks like done. Loop engineering is the discipline of designing that cycle well: what starts it, what feeds it context, when it spawns a helper, and how it knows to stop. The reason it went from niche trick to July 2026 headline is that the loop stopped being a party trick and started shipping real work.
Osmani’s framing is the one worth keeping. He lines loop engineering up as the fourth floor of a building: prompt engineering optimized the words you typed, context engineering optimized what filled the model’s window, harness engineering optimized the environment a single agent ran inside, and loop engineering is the harness put on a timer — spawning helpers, feeding itself, running while you sleep. Andrew Ng, in his letter on the pattern, mapped three loops at different tempos: an agentic coding loop that turns in minutes, a developer feedback loop measured in hours, and an external feedback loop that runs over days.
None of this would matter if agents still fizzled after ninety seconds. They don’t. METR’s Time Horizon 1.1 tracks the length of task a frontier model can finish at 50% reliability, and that horizon has been doubling roughly every four months since 2023 — closer to three months when you restrict the data to 2024 onward. Tasks that used to take an agent seconds now stretch to hours. That is exactly the runway a loop needs, and it is why long-horizon agents turned loop engineering from a curiosity into a practice.
Why does loop engineering make the work harder, not easier?
This is the part the buzz keeps skipping. If you stop writing prompts, it feels like you did less work. You didn’t — you moved the work up a floor. Osmani says it plainly: the leverage point shifted, and designing a good loop is harder than writing a good prompt, not easier. A prompt fails in front of you; you see the bad answer and fix it. A loop fails while you’re asleep, and by morning it has compounded ten iterations of a wrong assumption into something that looks finished.
It helps to break the loop into its three real jobs, because the viral version quietly collapses them into one. Every productive loop has to discover what to do next, execute the change, and verify that the change is actually good. The discourse of 2026 solved the middle leg beautifully. The while-loop that calls the model and runs tools is a triumph of engineering. But watch where the other two legs go when a solo developer runs a loop on a single repo: discover comes from the backlog in their head, and verify comes from their own eyes glancing at the diff. Both legs are load-bearing, and both are propped up by one human paying attention. Take that human away — which is the entire promise of the loop — and the legs have nowhere to stand.
The verify leg is the one that bites first, because a loop is perfectly capable of declaring victory over work that isn’t done. That failure already has a name. The Harvard Business Review study that coined workslop — AI output that looks finished but isn’t — surveyed 1,150 U.S. workers and found 41% had received it in the past month, each instance costing nearly two hours and about $186 per worker to clean up. Now picture a loop that grades its own homework. It doesn’t receive workslop; it produces it, confidently, on a timer, and hands it downstream as done. Self-certification isn’t verification. It’s workslop with a build badge.
What happens when you run more than one loop?
Here is the claim you won’t find on the rest of the loop-engineering internet, because the whole genre is written for one developer and one repo: the interesting failures start at loop number two. A single loop on a single codebase can get away with keeping discover and verify inside its own head. The moment you run a team of loops — and everyone is heading there, because a lone loop that runs while you sleep is too much leverage to keep to one — those two homeless legs become a coordination problem.
Call it the difference between a closed loop and an open loop. A closed loop discovers its next task from a private backlog and certifies its own success in isolation. Run five of them against overlapping work and they collide: two loops claim the same task, a third rebuilds something a fourth already shipped, and each one reports green because each one is grading itself. An open loop does the opposite — it reads its next task from a shared source of truth and writes a verifiable “done” back to that same place, where humans and other loops can see it, trust it, or contest it. The engineering the buzz obsesses over — permissions, context, subagents — is all interior decoration. Whether the loop is open or closed is the structural question, and it’s the one that decides if you can run more than one.
The stakes show up in the failure rate. Gartner predicts more than 40% of agentic AI projects will be canceled by the end of 2027, citing unclear value and inadequate controls — and the same firm expects 40% of enterprise apps to ship task-specific AI agents by 2026, up from under 5% in 2025. Read those two together: agents are proliferating fast, and the projects built on them are failing faster. The gap between the two numbers is mostly closed loops — lots of autonomous cycles running, none of them able to see or trust each other’s work. When a multi-agent system breaks, it usually breaks at the handoff, not inside any single agent. A team of closed loops is one long unmanaged handoff.
How does a shared board close the loop?
The fix isn’t a smarter loop. It’s giving the loop’s two homeless legs a place to live — and that place is a shared board. Put the work on a board where every task carries an explicit status, and the discover leg has a real source of truth: a loop claims its next task from the board instead of guessing, and the claim is atomic, so two loops can’t grab the same card. Make the board the place a loop posts its evidence, and the verify leg stops being self-certification: “done” becomes a status other loops and humans can inspect, not a badge the producer awarded itself. The loop opens.
That is what Lova is built to be — the shared surface an open loop reads from and writes to. An agent running a loop claims a task on the board, does the work, and moves the card through verifiable status with the evidence attached, exactly as a human teammate would. This matters most because loops run off-screen. The productivity of loop engineering comes from work happening while you aren’t watching, which is also the moment you lose all visibility into it. A board is where background work becomes visible again: not a chat log you have to reconstruct, but a live picture of what every loop claimed, shipped, and proved.
So the honest version of the 2026 headline is this. Yes, loop engineering replaced prompting — for the execute leg. But a loop that can’t discover its next task without a human, and can’t verify its own work without lying, hasn’t replaced the human. It has relocated the human’s job to designing the loop and running the board it reports to. The teams that win with loops this year won’t be the ones with the cleverest harness. They’ll be the ones who gave their loops somewhere to be honest. Design the loop, by all means — then open it onto a board.
Frequently asked questions
What is loop engineering?
Loop engineering is the 2026 practice of designing the automated system that prompts an AI agent for you — a repeatable cycle that discovers a task, executes the work, and verifies the result with minimal human input — rather than typing each instruction by hand. The term went viral in June 2026 after posts by Peter Steinberger and Anthropic’s Boris Cherny, and was formalized by Google’s Addy Osmani as the successor to prompt, context, and harness engineering.
Is loop engineering the same as prompt engineering?
No — it sits one level above it. Prompt engineering optimizes the words you type to a model. Loop engineering designs the system that does the prompting for you, so you stop being the operator and become the system designer. Osmani’s point is that this makes the work harder, not easier: a bad prompt fails in front of you, while a bad loop fails overnight and compounds.
Why do AI agent loops need a project board?
Because a loop has three legs — discover, execute, verify — and only execute is self-contained. A loop needs an external source of truth to know what to work on next, and an external record to prove its work is actually done rather than self-certified. A shared board supplies both: atomic task-claiming for discovery, and inspectable status for verification. Without it, multiple loops collide and each one grades its own homework.
Can loop engineering cause AI “workslop”?
Yes, and faster than a human can. Workslop — AI output that looks finished but isn’t — cost workers nearly two hours per instance in a 2025 Harvard Business Review study. A loop that verifies its own work will happily declare victory over unfinished output and ship it downstream on a timer. The guard is external verification: a “done” that lives on a shared board where others can check it, not a status the loop awarded itself.
How does Lova fit into loop engineering?
Lova is the shared board an open loop reads from and writes to. Agents claim tasks, post evidence, and advance verifiable status alongside human teammates, so the loop’s discover and verify legs live on a surface everyone can see — instead of inside a single harness nobody can audit. It’s how loop engineering scales from one developer and one repo to a team of loops that don’t collide.