# Loops explained: Claude, GPT, Mira and what actually works
**作者**: Anatoli Kopadze
**日期**: 2026-06-07T18:58:39.000Z
**来源**: [https://x.com/AnatoliKopadze/status/2068328135611822149](https://x.com/AnatoliKopadze/status/2068328135611822149)
---
AI has been in everyone's hands for years. Most people who use it every day still use it the slowest way there is: type a request, wait, fix it, ask again, all by hand.
Not because the faster way is complicated, because nobody showed them what it looks like.
The faster way is a loop, and right now it is the one thing the best AI engineers in the world care about. This article fixes the part nobody explained.
By the end you will understand loops better than almost anyone on your timeline: what they are, how they actually work under the hood, when they are worth it and when they are a trap, how to build a basic one yourself in Claude or ChatGPT, the simple ones worth running in your own life.
Before we get into it, follow me on X and join my Telegram channel I just created where I post more AI content every day. Both are free.
X - https://x.com/AnatoliKopadze
Telegram - https://t.me/kopadzemp
## How most people use AI?
Look closely at the one-request-at-a-time habit, because it is the whole problem. Every step runs through you. You decide what to ask, you judge the answer, you decide what comes next. The AI never moves unless you push it, and the moment you stop, it stops.
This is fine, but it has a ceiling. You are the engine. The AI is only the tool in your hand, and a tool does nothing on its own.
There is another way to work, and it is the reason the best engineers in the world are changing how they build. Instead of walking the AI through every step, you give it the goal once and let it run the steps itself. It plans, does the work, checks its own result, fixes what is weak, and repeats until the goal is met. You step out. The work keeps going.
> **Peter Steinberger @steipete**: [原文链接](https://x.com/steipete/status/2063697162748260627)
>
> Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore.
> You should be designing loops that prompt your agents.
Two of the most respected engineers, saying the same thing in different words. Most people read lines like these and quietly had no idea what they meant in practice. So let's break it down properly.
## What a loop is?
A prompt is a single instruction. A loop is a goal the AI keeps working toward until it gets there. Think of it as a recursive goal: you define a purpose, and the AI iterates until it is complete.
A prompt gives you one answer and then waits for you to decide what is next. A loop runs the full cycle on its own:
```
DISCOVER → work out what needs doing
PLAN → decide how to do it
EXECUTE → do the work
VERIFY → check it against the goal
ITERATE → not there yet? feed the result back in and repeat
```
Three of these five do all the real work, and they are where people get loops wrong.
Verify is the heart of the loop. Without a real check on the result, you do not have a loop, you have the agent agreeing with itself on repeat. The check is what turns repetition into progress. It can be a hard test ("does the code pass"), a measurable condition ("is the number above X"), or a rubric the model scores against. No gate means the agent grades its own homework, and the model that did the work is far too generous a grader.
State is what makes the loop learn. Each pass, the AI has to remember what it already tried, or it repeats the same mistake forever. A real loop keeps a small record on the side: what is done, what failed, what is next. Tomorrow's run resumes instead of starting from zero. This is also exactly where it starts getting expensive, which we will get to.
A stop condition is what keeps it sane. A loop with no exit runs until it succeeds, breaks, or drains your account. Every serious loop has two ways to stop: success, and a hard limit ("after 8 tries, stop and report"). Skip this and you have built a machine that can run all night for nothing.
A prompt hands the AI an instruction. A loop hands the AI a job, a way to know when the job is done, and a rule for when to give up.
## Do you even need one?
Most articles sell you the loop before they tell you when it is a mistake. Here is the test the serious people actually use. A loop is worth building only when all four of these are true:
- The task repeats, at least weekly. Less than that and the setup cost never pays itself back. A one-off is still better served by one good prompt.
- Something can automatically reject bad output. A test, a type check, a build, a linter, a hard rule. If nothing can fail the work for you, the loop just spins.
- The agent can actually do the work itself, end to end, not hand half of it back to you.
- "Done" is objective, not a judgment call. If quality is a matter of taste, a human still wins.
Miss one box, keep it as a manual prompt. The honest version of this whole topic: loop engineering is real, and most people do not need the heavy version yet. What everyone can use is the light version, which we will get to. But you should know where the line is.
## The version built for code
Loops took off in software first, because code is the easiest thing in the world to verify. A test passes or it fails. There is no arguing with it, so the AI always knows whether it is finished.
A coding loop is given a goal and a strict way to check it:
```
▸ LOOP SPEC
GOAL: every test in /tests/auth passes, lint is clean, no type errors.
EACH ITERATION:
1. run the test suite and read every failure
2. pick the single highest-impact failure
3. write the smallest change that fixes it
4. re-run the tests, lint, and type checker
VERIFY: green tests + zero lint warnings + zero type errors
STOP WHEN: verify passes, OR 8 iterations reached
ON STOP: summarize what changed and what still fails
```
Under the hood, a real loop is assembled from five building blocks. Claude Code and Codex now ship all five.
1. The automation (the heartbeat)
This is the trigger that makes it a loop and not a one-off you ran once. You define a prompt, a cadence, and a goal, and it runs on schedule without you starting it. In Claude Code, /loop re-runs a prompt on an interval, /goal keeps a session going until a condition you wrote is actually true, hooks fire commands at points in the agent's lifecycle, and pushing it to a cron job or GitHub Actions keeps it running after you close the laptop. Findings come to you. You are not the one going around checking.
2. The skill (reusable instructions)
Instead of pasting a wall of instructions into every run, you save them once as a file the loop reads every time: the rules, the patterns to follow, and a hard list of what it must never touch. Now the automation just calls the skill by name, and the recurring job stays maintainable instead of rotting inside a schedule nobody updates.
3. Sub-agents (keep the maker away from the checker)
The single most useful structural trick in a loop is splitting the agent that does the work from the agent that checks it. The model that wrote the code is too nice grading its own homework. A second agent, with different instructions and sometimes a stronger model on higher effort, catches the things the first one talked itself into. Your writer can be fast and cheap, your reviewer slow and strict. That separation is most of the quality.
4. Connectors (so it acts, not suggests)
This is the difference between an agent that says "here is the fix" and a loop that opens the pull request, links the ticket, and pings the channel once the build is green, by itself. Connectors are what let the loop act inside your real environment instead of just describing what it would do if it could.
5. The verifier (the gate)
The test, type check, or build that automatically rejects bad work. This is the one block that decides whether the loop helps you or just spends your money. Everything else is plumbing. This is the part that makes it real.
Stack those together and you get what big teams now run at scale: fleets of agents looping on the same job, dozens or thousands at once. One engineer used a loop like this to rewrite an entire codebase from one programming language to another in about six days, work that would have taken close to a year by hand. It is a genuine change in how serious software gets built. And it comes with a catch the demos never show.
## The cost nobody mentions
Loops run on tokens, and tokens are money. The problem is not that each step costs something. The problem is how the cost compounds.
Every time the loop goes around, the agent re-reads its context: the goal, the code, the last result, what failed. That whole pile is sent through the model again on every iteration, and it grows each pass. A loop that runs ten times does not cost ten prompts. It costs ten prompts that each keep getting bigger. The maker-and-checker trick that lifts quality also doubles the bill, because now two models read the work instead of one.
```
▸ ROUGH COST OF ONE LOOP
single agent, one medium task: ~50,000 – 200,000 tokens
context re-sent every iteration: grows each pass
a fleet of agents in parallel: multiply all of the above
```
The metric that actually matters, and almost nobody tracks, is cost per accepted change. Not tokens spent or loops run. If the loop gives you ten results and you toss six, you are doing the review work it was meant to save. Below a 50% accept rate, it costs more than it gives back.
Loops also fail quietly. Engineer Geoffrey Huntley calls it the "Ralph Wiggum loop": the agent decides it is done too early, exits on a half-finished job, and the loop keeps running and spending while producing nothing. Without a hard gate that can fail the work, loops do not crash, they bill you in silence.
That is why the heavy version belongs to teams with the budget and guardrails to run it: iteration caps, token budgets, cheap models on the boring steps, monitoring. If that is not you, you are not missing out, the core idea works at a fraction of the cost and none of the setup.
## The order that actually works
If you do build one, the order matters more than the tools. The people who ship loops that survive in production all do it the same way:
```
1. Get ONE manual run reliable first.
2. Turn that into a skill (save the instructions).
3. Wrap the skill in a loop (add the gate + stop condition).
4. THEN put it on a schedule.
```
Skipping ahead, scheduling something you have not made reliable by hand, is exactly how loops blow up while you sleep. Prove it once, harden it, then automate it.
## Build a basic loop yourself (any LLM)
You do not need a coding agent to feel how this works. You can run a simple loop by hand inside any LLM right now, with nothing but a prompt. The trick is to give the model all three loop parts at once: a goal, strict success criteria, and a protocol that forces it to check itself before it is allowed to stop.
```
▸ SELF-CHECKING LOOP (paste into Claude or ChatGPT)
You will work in a loop until the task meets the bar.
TASK:
[describe exactly what you want produced]
SUCCESS CRITERIA (be strict, no soft passes):
- [criterion 1]
- [criterion 2]
- [criterion 3]
LOOP PROTOCOL, repeat every turn:
1. PLAN - state the single next step.
2. DO - produce or improve the work.
3. VERIFY - score the result 1-10 on each criterion.
Be brutally honest. List exactly what is still weak.
4. DECIDE - if every criterion is 8+, print "FINAL" and stop.
Otherwise print "ITERATING" and go again, fixing
the weakest point first.
RULES:
- Never call it done until every criterion is 8 or higher.
- Each pass must fix the weakest score from the last VERIFY.
- Do not ask me questions. Make a sensible assumption, note it,
and keep going.
Begin. Run the loop until FINAL.
```
Watch what happens. The model drafts, grades its own work against your criteria, finds the weak spot, and rewrites, over and over, until it actually clears the bar instead of handing you the first thing that looked close. That is a loop. You just built one with a paragraph.
But notice what is still missing, because it is the whole point of what comes next. You are the trigger. You opened the chat, you pasted the prompt, you are sitting there watching it iterate. Close the tab and it is gone. There is no schedule. There is no "do this every morning," no "wake up when an email arrives." It cannot reach out to you, because it only exists while you are looking at it.
To get a loop that runs on its own, on a schedule, triggered by real events, without you babysitting it, you normally have to step into the heavy world from earlier: tools, hosting, code, gates, and a bill.
That makes sense when you are tackling genuinely heavy tasks. But for 99% of everyday ones, there is already a ready, dead-simple solution.
## The same idea, for your actual life
Strip away the code and the cost, and what is left is one simple, genuinely useful concept: a task that runs itself, on a schedule or the moment something happens, with no need for you to remember it or be there. You do not need to be an engineer for that. You just need loops built for life instead of for codebases.
There is a free option where you create one by describing it in plain words. No code, no hosting, no keys, no tab to keep open, no build order to get wrong.
It is called Mira, and it lives inside Telegram, the app you probably already have open. You message it like a friend, and the loops it runs are called Skills. Every Skill quietly has the same parts a real loop needs, a trigger, an action, a way to run by itself, except you never wire any of them together. You just say what you want.
```
▸ SKILL
"Every weekday at 7am, check my Gmail and Google Calendar.
Send me a short brief: my 3 most important meetings, anything
urgent in the inbox, and one thing I said I'd follow up on but
haven't. Keep it under 120 words."
```
That is a real loop. A time trigger, a multi-step action across two connected apps, running on its own and coming to you. You wrote it as one message.
## What Mira can actually do
Here is the part that makes it click. Mira is not a smarter chatbot. The difference from ChatGPT is simple: ChatGPT answers, Mira acts. You do not ask it to write the email, you tell it to send the email. You do not get a draft ticket, you get a real one in Linear with the owner assigned. It does the thing, in the background, and it remembers you between every conversation.
It connects to 500+ apps through Composio (Notion, Gmail, Google Calendar, GitHub, Figma, Stripe and hundreds more), it has long-term memory that holds across sessions and group chats, and it is model-agnostic, running GPT, Claude, Gemini depending on the task. Here is what that turns into.
For work
This is where the loops idea pays off without a single line of code.
```
▸ SKILLS
"An hour before each meeting, remind me with the context and
decisions from our last conversation with that person."
"When I forward a message here, turn it into a Linear ticket
with the right priority and assign the owner."
"Every Friday at 4pm, collect the team's task status and metrics
and post a clean weekly digest in our chat."
"Summarize everything I missed in this group chat while I was
away, in 5 bullets."
```
It catches you up on a 200-message thread in seconds, files the ticket while you keep talking, and walks into meetings already briefed. In group chats it remembers the team's decisions and tasks, not just yours.
For creators
This is the part most people underrate. Mira makes content end to end, inside the chat.
```
▸ SKILLS
"I'll send a voice note with a raw idea. Turn it into a finished
post with a caption and hashtags."
"Take this one idea and write versions for X, Instagram, LinkedIn,
Email, and a newsletter, each in the right format."
"Generate 3 image options for this post."
"Turn this image into a short video for my Telegram channel."
```
Voice note in, finished post out in about thirty seconds. One brief becomes six platform-native versions. It generates images and video right in the chat, edits photos, swaps backgrounds, builds mascots and avatars, even lip-syncs and animates them. The whole content pipeline lives in one window.
For voice
Mira treats voice as a first-class input, which matters more than it sounds.
```
▸ SKILLS
"Transcribe my voice messages into clean text."
"Read this article back to me as audio."
"Summarize the voice notes in this group chat into key points."
```
It transcribes your voice messages, reads text back to you, understands voice notes inside group chats and summarizes the discussion, and works as a hands-free voice assistant when you cannot type.
For your life
The same engine, pointed at everything else.
```
▸ SKILLS
"Every evening at 7, ask if I trained today. Keep a streak and
don't let me quietly skip more than one day."
"Every night, ask me 3 questions about my day, remember the
answers, and once a week tell me what changed."
"Track my calories from a photo of my plate."
"Watch this flight route and buy when the price drops to my number."
"Every morning, give me a no-clickbait news digest on my topics."
```
A coach that holds you to a streak. A journal that actually remembers you and becomes a check-in companion over time. Calorie tracking from a photo, no separate app. Language practice built from your own mistakes. A flight watcher that buys when the price is right. A daily digest with the clickbait stripped out.
## How to start in two minutes
Open Telegram. Go to Mira. Send it a message. Free access works immediately. Try one of these first:
```
@mira, plan my week
@mira, summarize this chat
@mira, remind me to review PRs every Monday at 9am
@mira, write a post about [topic] for X and Instagram
```
Any example in this article becomes a running loop the moment you type it.
## What this actually means for you
Loops are not a trend. They are a shift in who does the work. The AI stops waiting for you to push it through every step and starts running the whole job on its own.
That said, this isn't something to chase or force into places it doesn't belong. More often than not, you will just burn money for nothing.
My take: start by using what's already there for free, and only once you actually feel that it isn't enough should you start thinking about what you truly need.
If you want to stay up to date with everything happening in AI, follow me on X and Telegram:
X - https://x.com/AnatoliKopadze
Telegram - https://t.me/kopadzemp
## 相关链接
- [Anatoli Kopadze](https://x.com/AnatoliKopadze)
- [@AnatoliKopadze](https://x.com/AnatoliKopadze)
- [7.9M](https://x.com/AnatoliKopadze/status/2068328135611822149/analytics)
- [https://x.com/AnatoliKopadze](https://x.com/AnatoliKopadze)
- [https://t.me/kopadzemp](https://t.me/kopadzemp)
- [Jun 8](https://x.com/steipete/status/2063697162748260627)
- [8.3M](https://x.com/steipete/status/2063697162748260627/analytics)
- [Mira](https://t.me/mira?start=social_x_200626_howtostart)
- [https://x.com/AnatoliKopadze](https://x.com/AnatoliKopadze)
- [https://t.me/kopadzemp](https://t.me/kopadzemp)
- [9:40 PM · Jun 20, 2026](https://x.com/AnatoliKopadze/status/2068328135611822149)
- [7.9M Views](https://x.com/AnatoliKopadze/status/2068328135611822149/analytics)
- [View quotes](https://x.com/AnatoliKopadze/status/2068328135611822149/quotes)
---
*导出时间: 2026/6/23 17:57:59*
---
## 中文翻译
# 循环详解：Claude、GPT、Mira 以及真正有效的方法
**作者**: Anatoli Kopadze
**日期**: 2026-06-07T18:58:39.000Z
**来源**: [https://x.com/AnatoliKopadze/status/2068328135611822149](https://x.com/AnatoliKopadze/status/2068328135611822149)
---
AI 已经进入大众视野多年。大多数每天都使用它的人，依然停留在最慢的使用方式上：输入请求、等待、修正、再次询问，全靠手工操作。
这并不是因为更快的方式很复杂，而是因为没人给他们看过那是什么样子。
更快的方式就是“循环”，而这也是目前全球顶尖 AI 工程师所关注的核心。这篇文章将解开那个从未有人解释过的部分。
读完本文后，你对“循环”的理解将超过你时间线上几乎所有人：它们是什么、底层如何实际运行、何时值得使用何时是陷阱、如何在 Claude 或 ChatGPT 中亲手构建一个基础版本，以及那些值得在你自己实际生活中运行的简单版本。
在开始之前，请在 X 上关注我并加入我刚刚创建的 Telegram 频道，我每天会在那里发布更多 AI 内容。两者都是免费的。
X - https://x.com/AnatoliKopadze
Telegram - https://t.me/kopadzemp
## 大多数人是如何使用 AI 的？
仔细观察这种“一次一个请求”的习惯，因为这就是问题的根源。每一步都要经过你。你决定问什么，你判断答案，你决定下一步做什么。除非你推动，否则 AI 永远不会动；一旦你停下，它也就停了。
这样也没问题，但这有上限。你是引擎。AI 只是你手中的工具，而工具本身是不会自动做什么的。
还有另一种工作方式，这就是为什么全球最优秀的工程师正在改变他们的构建方式。不再是一步步牵着 AI 走，而是你给它一次目标，让它自己去运行这些步骤。它规划、执行工作、检查自己的结果、修正弱点，并不断重复直到目标达成。你退出，工作继续进行。
> **Peter Steinberger @steipete**: [原文链接](https://x.com/steipete/status/2063697162748260627)
>
> 这里是每月一次的提醒：你不应该再为了编码代理去写提示词了。
> 你应该设计循环，让循环去提示你的代理。
两位最受尊敬的工程师，用不同的话语表达着同一件事。大多数人读到这样的话时，其实并不知道它们在实践中意味着什么。那么，让我们来正确拆解一下。
## 什么是循环？
提示词是指单条指令。循环是 AI 持续为之工作的目标，直到达成该目标。可以把它看作一个递归目标：你定义一个目的，AI 会进行迭代直到完成。
提示词给你一个答案，然后等待你决定下一步。循环则独自运行整个周期：
```
DISCOVER → 弄清楚需要做什么
PLAN → 决定如何做
EXECUTE → 执行工作
VERIFY → 对照目标进行检查
ITERATE → 还没达标？将结果反馈回去并重复
```
这五个步骤中有三个负责所有实际工作，而这也是人们把循环搞砸的地方。
验证是循环的核心。如果没有对结果进行真正的检查，你就没有循环，你拥有的只是一个不断自我赞同的代理。检查是将重复转化为进化的关键。它可以是一个硬性测试（“代码是否通过”）、一个可衡量的条件（“数字是否大于 X”），或者是模型用来打分的评分标准。没有门槛意味着代理在批改自己的作业，而做过工作的模型对自己实在太宽容了。
状态是让循环学习的原因。每一轮，AI 都必须记住它已经尝试过什么，否则它会永远重复同样的错误。真正的循环会在侧面保留一个小记录：做了什么、失败了什么、下一步是什么。明天的运行会从中断处恢复，而不是从零开始。这也是成本开始变得昂贵的地方，我们稍后会谈到。
停止条件是保持循环理智的关键。没有出口的循环会一直运行，直到成功、崩溃或耗尽你的账户。每个严肃的循环都有两种停止方式：成功，和一个硬性限制（“尝试 8 次后停止并报告”）。跳过这一步，你就制造了一台可能整晚白跑的机器。
提示词是交给 AI 一条指令。循环是交给 AI 一项工作、一种知道工作何时完成的方法，以及一条何时放弃的规则。
## 你真的需要一个吗？
大多数文章在告诉你何时是个错误之前，就先向你推销循环。以下是严肃的人实际使用的测试标准。只有当以下四个条件全部为真时，构建一个循环才是值得的：
- 任务是重复的，至少每周一次。低于这个频率，设置成本永远无法回本。一次性任务最好还是用一个好的提示词来解决。
- 某种机制可以自动拒绝糟糕的输出。一个测试、类型检查、构建、Linter 或硬性规则。如果没有任何东西能替你否决工作，循环就会空转。
- 代理实际上可以端到端地独立完成工作，而不是把一半甩回给你。
- “完成”是客观的，而不是主观判断。如果质量取决于品味，人类仍然更胜一筹。
只要少一个条件，就把它保留为手动提示词。关于这个话题的诚实版本是：循环工程是真实的，但大多数人还不需要那种重型版本。每个人都能使用的是轻量版，我们稍后会讲到。但你应该知道界限在哪里。
## 为代码构建的版本
循环首先在软件领域爆发，因为代码是世界上最容易验证的东西。测试要么通过，要么失败。没有争辩的余地，所以 AI 总是知道它是否完成了。
一个编码循环被赋予一个目标和一种严格的检查方式：
```
▸ 循环规格
目标：通过 /tests/auth 中的所有测试，Linter 干净，无类型错误。
每次迭代：
1. 运行测试套件并阅读每一个失败项
2. 选择影响力最大的那一个失败项
3. 写出修复它的最小改动
4. 重新运行测试、Linter 和类型检查器
验证：绿色测试 + 零 Linter 警告 + 零类型错误
停止条件：验证通过，或达到 8 次迭代
停止时：总结改变了什么以及什么仍然失败
```
在底层，一个真正的循环由五个构建块组成。Claude Code 和 Codex 现在已内置了这五块。
1. 自动化（心跳）
这是让循环成为循环、而不是你运行一次就完事的一次性任务的触发器。你定义一个提示词、一个节奏和一个目标，它就会按计划运行，无需你启动。在 Claude Code 中，`/loop` 按间隔重新运行提示词，`/goal` 保持会话进行，直到你编写的条件实际为真，钩子会在代理生命周期的节点触发命令，而将其推送到 cron 任务或 GitHub Actions 则能在你合上笔记本后保持运行。结果会主动找你。你不是那个到处检查的人。
2. 技能（可复用的指令）
不再每次运行都粘贴一大段指令，而是将它们保存为循环每次读取的文件：规则、要遵循的模式，以及绝不能触碰的硬性清单。现在自动化只需按名称调用技能，周期性工作也能保持可维护，而不是在无人更新的计划中腐烂。
3. 子代理（让执行者远离检查者）
循环中最有用的结构技巧是将执行工作的代理与检查工作的代理分开。编写代码的模型在批改自己的作业时太宽容了。第二个代理，拥有不同的指令，有时在更高难度的任务中使用更强的模型，能捕捉到第一个代理自我说服的部分。你的写作者可以快速廉价，你的审查员可以缓慢严格。这种分离是质量的大部分来源。
4. 连接器（让它行动，而不是建议）
这就是说“这是修复方案”的代理与自动打开拉取请求、链接工单、并在构建变绿后 ping 频道的循环之间的区别。连接器让循环能在你的真实环境中行动，而不仅仅是描述它如果能做会做什么。
5. 验证器（门槛）
自动拒绝劣质工作的测试、类型检查或构建。这是决定循环是帮了你还是仅仅花了你的钱的唯一模块。其他一切都是管道工程。这是让它变得真实的部分。
把这些堆叠在一起，你就得到了大团队现在大规模运行的东西：成群的代理在同一任务上循环，一次几十个甚至几千个。一位工程师用这样的循环在大约六天内将整个代码库从一种编程语言重写为另一种语言，而手工操作需要近一年时间。这是严肃软件开发方式的真正变革。但这伴随着演示从未展示过的陷阱。
## 没人提及的成本
循环运行在 Token 上，而 Token 就是钱。问题不在于每一步都要花钱。问题在于成本是如何复合增长的。
每次循环运行，代理都会重新读取它的上下文：目标、代码、上次的结果、失败的部分。这一整堆内容在每次迭代时都会再次通过模型发送，并且每过一轮都会变大。运行十次的循环成本不只是十个提示词。而是十个不断变大的提示词。提升了质量的制造者与检查者技巧也会让账单翻倍，因为现在是两个模型在读取工作而不是一个。
```
▸ 一个循环的大致成本
单个代理，一个中型任务： ~50,000 – 200,000 tokens
每次迭代重新发送的上下文： 每一轮都在增长
并行的代理集群： 将以上所有乘以倍数
```
真正重要且几乎没人追踪的指标，是“每次被接受的变更”的成本。而不是消耗的 Token 或运行的循环次数。如果循环给你十个结果而你扔掉了六个，你实际上是在做本该由它帮你省掉的审查工作。低于 50% 的接受率，它的成本就超过了收益。
循环还会悄无声息地失败。工程师 Geoffrey Huntley 称之为“Ralph Wiggum 循环”：代理过早地认为自己完成了，在半吊子的工作上退出，而循环继续运行并花钱，却不产出任何东西。如果没有一个能拒绝工作的硬门槛，循环不会崩溃，它们只会静默地给你账单。
这就是为什么重型版本属于那些有预算和护栏来运行它的团队：迭代上限、Token 预算、无聊步骤使用廉价模型、监控。如果那不是你，你并没有错过什么，核心思想只需一小部分成本就能实现，且无需任何设置。
## 真正有效的顺序
如果你真的要构建一个，顺序比工具更重要。那些在生产环境中存活下来的循环构建者都这样做：
```
1. 首先确保单次手动运行可靠。
2. 将其转化为技能（保存指令）。
3. 将技能封装进循环（添加门槛 + 停止条件）。
4. 然后将其放入计划表。
```
跳过步骤，把还没手动验证可靠的东西放入计划，正是循环在你睡觉时爆炸的原因。先验证一次，加固它，然后再自动化。
## 亲手构建一个基础循环（任何大模型）
你不需要编码代理也能感受这是如何运作的。你现在就可以在任何大模型中手动运行一个简单的循环，只需一个提示词。技巧是一次性给模型所有三个循环部分：一个目标、严格的成功标准，以及一个强迫它在停止前检查自己的协议。
```
▸ 自检循环 （粘贴到 Claude 或 ChatGPT）
你将在一个循环中工作，直到任务达到标准。
任务：
[准确描述你想要产出的内容]
成功标准（要严格，没有软性通过）：
- [标准 1]
- [标准 2]
- [标准 3]
循环协议，每一轮重复：
1. 计划 - 说明唯一的下一步。
2. 执行 - 产出或改进工作。
3. 验证 - 在每个标准上给结果打分 1-10 分。
要极其诚实。准确列出哪里仍然薄弱。
4. 决定 - 如果每个标准都达到 8 分以上，打印 "FINAL" 并停止。
否则打印 "ITERATING" 并再次运行，优先修复
最薄弱的点。
规则：
- 在每个标准达到 8 分或更高之前，绝不要宣布完成。
- 每一轮必须修复上一次验证中的最低分项。
- 不要问我问题。做出合理的假设，记录下来，
然后继续。
开始。运行循环直到出现 FINAL。
```
观察接下来发生的事。模型起草，根据你的标准给自己的工作打分，找出弱点，并重写，一遍又一遍，直到它真正达到标准，而不是把第一个看起来差不多的东西交给你。这就是循环。你刚刚用一段话构建了一个。
但注意仍然缺失了什么，因为这正是接下来的重点。你是触发器。你打开聊天，你粘贴提示词，你坐在那里看着它迭代。关闭标签页，它就消失了。没有计划表。没有“每天早上做这个”，没有“收到邮件时醒来”。它无法主动找你，因为只有当你看着它时它才存在。
要获得一个自动运行、按计划、由真实事件触发、无需你照看的循环，通常你需要进入前面提到的重型世界：工具、托管、代码、门槛和账单。
当你处理真正繁重的任务时，这是合理的。但对于 99% 的日常任务，已经有一个现成的、极其简单的解决方案。
## 同样的思路，用于你的真实生活
剥离代码和成本，剩下的就是一个简单、真正有用的概念：一个按计划或在某事发生时自动运行的任务，无需你记住或在场。你不需要成为一名工程师也能做到。你只需要为生活而不是为代码库构建的循环。
有一个免费的选项，你可以用通俗的语言描述来创建一个。没有代码，没有托管，没有密钥，没有需要保持打开的标签页，没有会搞错的构建顺序。
它叫 Mira，住在 Telegram 里，那个你可能本来就会打开的应用。你可以像给朋友发消息一样给它发消息，它运行的循环被称为“技能”。每个技能都悄悄拥有真实循环所需的相同部分，一个触发器、一个动作、一种自行运行的方式，除了你从不需要把它们连在一起。你只需要说出你想要的。
```
▸ 技能
"每个工作日上午 7 点，检查我的 Gmail 和 Google 日历。
给我发一份简报：我最重要的 3 个会议，收件箱里的
任何紧急事项，以及一件我说过要跟进但还没做的事。
控制在 120 字以内。"
```
这是一个真正的循环。一个时间触发器，跨两个关联应用的多步动作，自动运行并主动找你。你只用一条消息就写好了它。
## Mira 实际上能做什么
这是让一切豁然开朗的部分。Mira 不是更聪明的聊天机器人。它与 ChatGPT 的区别很简单：ChatGPT 回答，Mira 行动。你不是让它写邮件，你让它发邮件。你得到的不是草理工单，你得到的是 Linear 里的真工单并分配了负责人。它在后台做这件事，并在每次对话之间记住你。
它通过 Composio 连接 500 多个应用（Notion、Gmail、Google 日历、GitHub、Figma、Stripe 和数百个其他应用），它拥有跨会话和群聊的长期记忆，并且它与模型无关，根据任务运行 GPT、Claude 或 Gemini。这就是它转化成的样子。
用于工作
这就是循环思路无需一行代码就能兑现回报的地方。
```
▸ 技能
"每次会议前一小时，用我们上次与该人谈话的背景
和决策提醒我。"
"当我转发一条消息到这里时，将其转化为 Linear 票据，
设定正确的优先级并分配负责人。"
"每周五下午 4 点，收集团队的任务状态和指标，
并在我们的群聊中发布一份干净的每周摘要。"
"用 5 个要点总结我不在时在这个群聊中错过的所有内容。"
```
它几秒钟内就能帮你了解 200 条消息的线程，在你继续说话时帮你提交票据，并带着预先的简报走进会议。在群聊中，它记住团队的决策和任务，而不仅仅是你的。
用于创作者
这是大多数人低估的部分。Mira 端到端地创作内容，完全在聊天内部。
```
▸ 技能
"我会发送一条语音笔记，包含一个原始想法。把它转