Background
In June 2026, Peter Steinberger's post — "You shouldn't be prompting Agents anymore. You should be designing loops that prompt Agents" — hit 2.2 million views in 48 hours. Addy Osmani followed with a deep breakdown of what he calls Loop Engineering, and the community fractured between evangelists, skeptics, and security realists.
Core idea: instead of a human typing to an Agent, reading a reply, and typing again, the human is removed from the loop and replaced by a program.
The Six Components of a Loop
1. Automations — the heartbeat. Without a timer you just used an Agent once. /loop is time-driven (rerun every N minutes); /goal is condition-driven (stop only when tests pass and lint is clean). Boris Cherny's production Loops include a PR babysitter, CI health monitoring, and feedback clustering from Twitter.
2. Worktrees — parallel without collisions. Each Agent works in its own Git worktree checkout. Osmani's caveat: worktrees remove mechanical collisions, but your review bandwidth is the real limit.
3. Skills — stop being a goldfish. A SKILL.md file plus optional scripts. The reusable unit inside a Loop is the Skill, not the prompt. Loops that call well-named Skills compound; Loops that re-derive everything just burn money.
4. Connectors — reaching the world. Via MCP, the Agent reads issue trackers, queries databases, calls staging APIs, posts to Slack. Fix code → open PR → link ticket → notify channel automatically.
5. Sub-agents — maker-checker separation. The model that writes code grades itself too kindly. One Agent writes; a second, differently-instructed Agent verifies. This matters most because you're not watching while the Loop runs — a verifier you trust is the only reason you can walk away.
6. State — Agents forget, the repo doesn't. A Markdown file or Linear board persisted outside the conversation; each run picks up where the last stopped. This is the spine of the Loop.
Why the Community Split
- Hype camp: "This is the future." Mohammed Wasif built a Mac app (Supervisor) that feeds tailored prompts into every session; Steinberger runs Loops like Mantis (Agent records bug videos and fixes them) and Auto Review.
- Cold camp: "Cron jobs have funny re-branding rn." Sead Dzambegovic: my skills already get ~90% completion; the rest burns tokens and still needs my review. Another take: "Literally RL 101" — ReAct (2022), AutoGPT (2023), Ralph Loop (2025) all did this.
- Security/risk camp: "Bigger capabilities, bigger holes" — security policy must be part of the loop orchestrator's control plane. Keane's sharpest cut: code loops have a free oracle (tests, compilers); every other domain's oracle is a human, and nobody has solved that yet.
- Practitioners' notes: semi-automated setups get stuck at the hardest step — handing prompts between agents. Non-programmers report no use case requiring all six components.
- Verification stays on you. "Done" is a claim, not proof.
- Comprehension debt. The faster a Loop delivers code you didn't write, the wider the gap between what exists and what you understand — unless you read.
- Cognitive surrender. When the Loop runs, humans naturally stop forming opinions. Designing the Loop to use your judgment is the antidote; using it to avoid thinking is the accelerator. Same action, opposite outcomes.
Three Core Judgments
1. Not new tech — new productization
Every core technique existed before. But productizing /goal changed the stop condition from "I feel done" to "all tests pass," and the grader from self to a separate model. An honest definition: a Loop is cron trigger + an AI that decides situationally after each trigger. The real engineering is making sure that AI doesn't run off a cliff.
2. AlphaSignal's four conditions — all must hold
1. The task is repetitive (amortize setup cost). 2. Verification is automatable (tests, type checkers, linters). 3. Your token budget absorbs waste (Uber capped spend at $1,500/person/month/tool after blowing its annual AI budget). 4. The Agent already has senior-engineer tooling (logs, repro environments).
Good first Loops: CI failure triage, dependency upgrade PRs, lint-and-fix, flaky test reproduction. Bad first Loops: architecture rewrites, auth/payment code, production deploys, judgment-dependent "done."
3. The real ceiling isn't what you think
Osmani names three problems that get *sharper* as Loops improve:
Conclusion
Loop Engineering is neither a lie nor a revolution. Cherny reports that over the past 30 days, 100% of his contributions were written by Claude Code itself — 259 PRs merged — and he deleted his IDE in November 2025. But note what he deleted: the IDE, not judgment. He still decides what to build, talks to users, coordinates the team. The work didn't vanish; it moved up a level — from writing code to writing the thing that writes code.
Keane's observation is the natural boundary: software engineering is the only domain where an Agent can automatically verify its own work. Everywhere else — writing, design, product decisions — a Loop is just "a cron job with an LLM."
You can build Loops, but don't expect them to replace understanding. Loops make you fast. Judgment makes you right. You need both.
> References: Addy Osmani, "Loop Engineering" (2026-06-07); AlphaSignal's four-condition analysis; community discussion threads on X.