AI Agent 循环（Loop）的 15 个真实用例与工程陷阱

Earlier this month I wrote WTF Is a Loop? Peter Steinberger vs. Boris Cherny, which did 3.6M views on what a loop even is. This is the sequel, and it answers the next question: which loops do people actually run? I pointed /last30days (@slashlast30days) at exactly that, eight searches across X, TikTok, Reddit, YouTube, and GitHub. Below are the fifteen best that came back, every one attributed, with real engagement where it went viral and honest provenance where it came from a curated catalog, rewritten as a command you can paste tonight if there wasn't one. First, the one distinction almost everyone gets wrong.

First, the three commands (this is where everyone trips)

The cleanest way to say it surfaced from a creator named inyourhandmedia on TikTok: Goal is keep working until the outcome is achieved. Loop is keep repeating a task while I am here. Routine is keep working while I am gone. In real commands:

• /goal <condition> runs until a verifiable condition is true, then stops. A separate fast model checks after every turn whether you are actually done. This is the one for "fix it until the tests pass," and it is the one command both tools share: Claude Code shipped it in v2.1.139 (docs), and Codex shipped its own in CLI v0.128.0 with set, pause, resume, and clear controls (docs).

• /loop <interval> <prompt> repeats on a timer while your session is open, like /loop 5m check the deploy. It is for watching something, hands on, right now (docs). Codex has no /loop command yet; its equivalent is codex exec wrapped in a shell loop, or a minute-interval Thread Automation in the Codex app.

• /schedule <description> creates a cloud Routine that runs while your laptop is closed, like /schedule daily PR review at 9am (docs). This is the "while I sleep" one. Codex's equivalent is Automations in the Codex app: standalone, project, or thread automations on a daily, weekly, or custom cron schedule, with results landing in a Triage inbox (local now, cloud execution rolling out).

One trap that comes up constantly in the threads: there is no /routine command in either tool. In Claude Code the scheduler is /schedule; in Codex it is Automations in the app. Get the verb right and every loop below just works. Eleven of these came straight off X, TikTok, Reddit, and GitHub with the engagement attached; the last four I lifted from the one catalog worth raiding, and I have flagged exactly which.

1. The build-test-fix pair (loop)

The single most-demoed loop in the whole pull, from a creator named raycfu whose walkthrough did 43,587 views and 1,040 comments on Instagram. Two agents: a builder that writes code and a checker that runs the tests, types, and lint and reports exactly what broke. They pass work back and forth until it is clean. The whole pitch is the pain it kills: a one-shot agent ships its bugs.

https://developers.openai.com/codex/app/automations

2. Boris's verifier loop (loop)

This is the loop in Boris Cherny's own words, and the highest-engagement description of it (@bcherny, 781 likes): run Claude Code plus an advanced model plus a verifier in a loop, feed it tasks, and remove bottlenecks as you go. The verifier is the part everyone skips. Without it you are just trusting the agent.

https://www.reddit.com/r/n8n/comments/1tmxgry/how_are_you_handling_humanintheloop_steps_in/

3. The loop-engineer starter (harness)

The most-watched actually-set-one-up video, from AI Jason (15,436 views, 537 likes), ships a free loop-engineer template: a codebase harness plus a knowledge template you clone, point at your repo, and run, so you are not wiring the build, observe, verify, and stop scaffolding from scratch. The fastest on-ramp if you want a loop running tonight without designing the plumbing yourself.

https://github.com/Forward-Future/loop-library

4. The five-minute repository maintainer (loop)

Peter Steinberger, who merged 859 PRs across his repos in the last 30 days at a 95 percent acceptance rate, runs this one on a tight timer: every five minutes while he is working, the agent does one small, verified piece of upkeep. What to clean is the agent's call, not a hardcoded script. That decision is the whole point.

/loop work the task list. After each task, have a separate verifier model
check the result against the spec and the tests. Only move on when it
passes. Surface anything the verifier rejects twice.

5. The plan-generate-verify-fix loop (goal)

A creator named qbuilder (4,560 views, 125 likes on TikTok) runs a bounded version that fixes the runaway problem cold: plan, generate, verify, fix, repeat, with everything saved to files and a hard cap of five iterations. You only read the final version. The cap is what makes it safe to leave.

roborev init    # adds a post-commit hook: every commit triggers a review
roborev fix     # the agentic loop that fixes the surfaced findings

6. roborev, the post-commit reviewer (shipped tool)

roborev is a free, open-source code-review tool (a Go binary; install from roborev.io) that surfaced in the research through Dan Kornas. It installs a git hook so every commit triggers a background review, then feeds the findings into an agentic fix loop while the context is still warm. The launch tweet was quiet at 20 likes, but the repo is the real signal: 1,410 stars and commits shipping the same day I write this. It is the installable version of the one thing this whole piece argues is the hard part, a verifier living inside the loop, and it plugs into Claude Code, Codex, and Gemini CLI.

https://www.instagram.com/reel/DZysNLJv_yv/

7. The goal-meta-skill (goal)

The breakout skill of the month, surfaced by evgenii.arsentev (32 likes, 950 views) and sitting at 600-plus stars in days: a skill whose only job is to turn a vague ask into a rigorous goal, specifying the result, how to verify it, what not to touch, and when to stop. As he put it, your agent is not dumb, your instructions are just vague.

https://github.com/roborev-dev/roborev

8. The 15,000-emails-a-day loop (routine)

A builder on r/LangChain posted the full architecture for an email agent that processes 15,000 hotel guest emails a day: it loops the inbox, classifies and drafts, and escalates only what needs a human. It is the rare Reddit post that ships the whole production loop, not a demo.

/schedule every night, watch my open PRs. Auto-fix build failures, answer
review comments in a fresh worktree, and rebase what is stale. Leave
anything ambiguous for me. State in git so a crash loses nothing.

9. The anti-spin loop (loop)

The best-designed loop on Reddit, a Claude Code skill posted to r/claudeskills. It runs an autonomous build, audit, and verify cycle until a machine-checkable contract passes, with explicit anti-spin stops: no-progress detection, a retry cap, flip-flop detection, and a budget. It exists because, as the author puts it, most agent loops never stop to ask whether they are actually making progress, so they retry the same broken approach or quietly edit the test to pass.

https://code.claude.com/docs/en/scheduled-tasks

10. The write-loops-not-code routine (routine)

The line that started all of this, from the man who built Claude Code: he does not write code anymore, he writes loops, and they write the code while he sleeps. The most-shared version (@0xMovez, 984 likes) puts a number on it: 30 percent of his code is now fully written by loops. The shape is a scheduled routine that watches your PRs and lands the fixable ones overnight.

https://github.com/mvanhorn/last30days-skill

11. The human-in-the-loop approval queue (loop)

The most practical pattern from the no-code crowd, from a thread on r/n8n: the workflow runs, then pauses and sends you a message with approve, revise, or skip buttons, treating human review as its own queue with reminders and deadlines. Same loop shape, but the stop condition is your approval instead of a passing test.

https://x.com/steipete

And four worth lifting from the catalog

The rest of the truly copy-paste-ready loops live in Matthew Berman's Forward Future Loop Library, a curated catalog where the vetting, not a like count, is the signal. These four earned a slot on usefulness alone.

12. The production error sweep (goal, catalog)

Berman's highest-utility goal. It reads your production logs, separates real actionable errors from noise, fixes the actionable ones with a test, and opens a PR. The value is the triage; tell it what "actionable" means or it chases ghosts.

https://x.com/0xMovez/status/2068074207687201043

13. The quality streak loop (goal, catalog)

Berman again, and the one that respects how flaky "it works" really is. It does not stop at the first green run; it tests realistic scenarios and only declares victory after a streak passes in a row. One green run is luck. A streak is reliability.

https://x.com/mvanhorn/status/2063865685558903149

14. The adversarial-review power tool (shipped command, catalog)

Lukas Kucinski's Clodex loop has Codex review Claude's pull requests before merge, so two different model families have to agree before code lands. Paste it verbatim.

https://www.reddit.com/r/LangChain/comments/1tz9mdm/how_i_built_an_ai_email_agent_that_processes/

The --max-iter 5 and --threshold medium are the whole point. It argues with itself up to five times and only passes work that clears the bar.

15. The completion-contract power tool (shipped command, catalog)

3goblack's loop (@Dis_Trackted) fixes the most common failure: an agent that says "done" when it is not. Before any work starts it writes a contract of what "complete" means and what evidence proves each requirement, then refuses to claim success without that evidence.

/goal review the last 24h of production errors. For each one that is
actionable and reproducible, write a fix with a regression test and open
a PR. Ignore transient and third-party noise. Done when the actionable
list is clear.

The part the hype skips: a loop is a money fire with a verifier on top

Across every platform, the same two warnings came back, and they are funnier in the community's words than in mine.

The first is cost. The romantic version of loops is "a thousand agents build my company overnight." The production version is a bill. Uber capped its engineers at fifteen hundred dollars per tool per month after burning its annual AI budget in four months. One Reddit poster torched about six thousand dollars overnight with one command, a thread that drew 1,273 upvotes. The funniest summary of the whole movement is a YouTube comment written as code.

while (you have tokens): Burn them in a loop! That's what it is

• TrMarwane, YouTube, 196 likes, on a loop-engineering breakdown

So every goal gets a budget and every loop gets a cap. Goal conditions can carry "or stop after N turns." Routines run on a plan with a daily ceiling. Set the ceiling before you walk away, not after the email arrives.

The second is verification, and it is the entire game. A loop that cannot tell good output from bad does not save you work. It just produces wrong answers faster.

a loop that can't actually tell good output from bad just automates being wrong, faster. writing the loop is easy. the verifier inside it is the hard part.

• @ahmetbilicanxyz

This is why /goal runs a separate model as judge instead of letting the worker grade its own homework, and why the strongest loops above (Boris's verifier, the build-test-fix pair, Clodex) all put a second, independent set of eyes inside the loop. An agent grading itself will delete the failing test and call it done. The skeptics are right to keep this honest.

Here we go again. We have a new AI trend: Loop Engineering. Are you still writing prompts? You are so behind.

• Maximilian Schwarzmuller, YouTube, 2,036 likes, on his loop-engineering video

He is half right. The scheduling layer really is just cron. What cron never had is a decision-maker in the body that reads the state, acts, checks whether it worked, and decides whether to keep going. That decision is the whole new thing. Everything else is plumbing.

How to start tonight

You do not need all fifteen. The research kept converging on three moves, one of each kind. Run the build-test-fix pair as a /loop so something measurably improves while you watch. Run the five-minute maintainer as a /loop while you work. Run the write-loops PR routine as a /schedule overnight so you wake up to finished work. Give each one a budget and a verifier. That is a working loop stack by tomorrow morning.

Then go browse the rest. Matthew Berman's Forward Future Loop Library catalogs the copy-paste loops with their authors credited, and the loops live in an open repo you can install. But the spine of this piece is not his catalog. It is what people are actually running and posting, pulled out of a month of noise so you do not have to.

The shift everyone is circling is real, and it is simpler than the discourse. Stop being the thing in the loop. Write the goal, the loop, or the routine, give it a budget and a way to check itself, and go decide what to build next. As one tired practitioner put it when someone asked what you are even supposed to do while the agent works:

Go for a walk. Call your mom. Make a healthy meal. Take care of yourself.