Latent.Space · AINews · 2026-06-12

Loopcraft:
叠加循环的艺术

三位顶级 AI 工程师——Steipete、Boris Cherny、Karpathy——这周同时说"我不再 prompt agent,我写 loop"。swyx 借机把这件事上升成一个世纪命题:下个世纪的游戏,就是把 loop 叠起来做到极致。我们做了工程级拆解 + 压力测试 + 4 条切你自己的洞察。

~4500 翻译 + 解读字数
15 min 阅读时间
Latent.Space 来源(付费周刊)
工程级 难度(含拆解 + DIY 对比)
Part 1

Magazine Article · 工程级解读

这篇文章回答:当最强的 AI 工程师都说"我不再 prompt agent",背后到底是种什么工作方式?
应该回答但没回答:loop 里的 agent 不可靠时(96% 说谎率、$250 一个 PR),叠加 loop 是放大可靠性还是放大错误?

1. 这周的"Loop 话语"为什么值得停下来听

这是个新闻相对安静的周期,swyx 借机把三条重量级人物的话摆在一起:

Peter Steinberger(Steipete,PSPDFKit 创始人,AI 工程圈知名实践者)

这是每个月的提醒:你不应该再手 prompt 编码 agent 了,你应该设计 loop,让 loop 去 prompt 你的 agent。

"Here's your monthly reminder that you shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."

Boris Cherny(OpenAI Codex 团队 lead,前 Meta Llama)

我不再 prompt Claude 了。我写 loop,loop 来做工作。

"I don't prompt Claude anymore. I write loops, the loops do the work."

Andrej Karpathy(OpenAI 联创,前 Tesla AI 总监,刚在跑 Autoresearch)

要把这些工具用到极致,你必须把自己从瓶颈里挪出去。你不能在那里等下一个 prompt。你必须把自己抽出来,让事情完全自治——能拉满 token throughput、自己不在 loop 里,这才是目标。这场游戏的名字就是放大你的杠杆……我不想做那个看结果的 loop 内的研究员,我在拖系统的后腿。所以问题是:我该怎么重构所有抽象,让我自己不在其中——一次配置好,按下 go。

三个人三句话,指向同一件事:手工 prompt 已经是从前的人了。下一步是把 agent 包进可重复、自治、自动收敛的循环里。

2. swyx 的关键加码:你已经在很多 loop 里了

swyx 没只是转述。他补了一个被低估的观察:"people don't realize how many loops we are already in"(人们没意识到自己已经在多少个 loop 里了)。我用文字复原他贴的两张配图:

你已经在里的 Loop触发器谁在循环
CI/CD pipelinegit push编译器 + 测试 + linter
Code reviewPR 创建reviewer + 作者
Cron job时间到scheduler + 任务
监控告警指标越线oncall + 修复
Hacker News / Twitter 刷新你无聊推荐算法 + 你
TDD(红绿重构)测试红你 + 测试
ChatGPT 多轮对话你回一句LLM + 你

swyx 的洞察是:这些 loop 早已存在,它们之间的差别只是「谁在执行迭代」。当 agent 接管执行的那一天,loop 的拓扑没变,变的是 loop 内的 token throughput。

3. 全文最核心的一句:UP a loop vs DOWN a loop

请认真读这句话:

可以说,下个世纪整个游戏就是把 loop 叠起来(stack loops)做到尽可能高效。在每个阶段的早期,知道何时往下一个 loop(DOWN)——出错时为了可靠性——是有价值的;但更可能更有价值的,是知道如何往上走一个 loop(UP)——模型变强时,为了杠杆

"One might argue the entire game of the next century is to be able to stack loops as effectively as possible. In the early days of each phase, it will be valuable to know when to go DOWN a loop when things go wrong (for reliability)… but it will probably be more valuable to know how to go UP a loop as models improve (for leverage)."

这句话给了 loop stacking 一个方向性的判断标准

DOWN a loop(降级保稳定)

agent 做事反复出错 → 退到外层 loop → 外层决定"换 agent / 换 prompt / 换工具"。

何时用:早期、模型弱、任务脆。
本质:保守策略。

UP a loop(升级换杠杆)

发现自己在做的事能被外层 loop 调度(手工跑 5 个 sub-task → orchestrator 自动分派)→ 把自己挪上去。

何时用:成熟期、模型强、任务可批量。
本质:激进策略。

swyx 的判断是——模型变强的速度会让 UP 的价值持续超过 DOWN

4. The Salty Lesson for Agents(镇文之宝)

swyx 仿 Rich Sutton 的 The Bitter Lesson(《苦涩的教训》)写了 The Salty Lesson(《咸味教训》,名字本身就带情绪):

别像你历史上做的那样自己修东西。
要聚焦在那些能随着 agent 数量扩展的系统上——比如目标和编排。

"Don't fix things yourself, as you have done historically.
Instead focus on systems that scale with more agents, like goals and orchestration."

逐字拆:

  • "Don't fix things yourself" —— 不是"不要修 bug",是"不要用手工的人类智慧去解决具体问题"。
  • "as you have done historically" —— Sutton 原文的语气复刻:你过去 20 年的工程直觉是错的。
  • "scale with more agents" —— 你的产出应该和 agent 数量成正比。加一个 agent 不能让你的产能 +1,说明你做错了。
  • "goals and orchestration" —— 人类只做两件事:定义目标(goals)、定义 agent 之间的编排(orchestration)。其他交给 agent。

这跟 Karpathy 的"arrange it once and hit go"完全一致——你只配置一次,剩下的让 loop 跑。

5. 工程级拆解:到底什么是 "Loop"?

"loop"这个词被用得太玄。把它工程化:一个 agent loop 至少包含五个组件

┌─────────────────────────────────────────────────┐
│  Orchestrator Loop(外层,人类设计)             │
│                                                  │
│  ┌────────────────────────────────────────┐     │
│  │  Goal Spec(目标定义)                  │     │
│  └────────────────┬───────────────────────┘     │
│                   ↓                             │
│  ┌────────────────────────────────────────┐     │
│  │  Agent Loop(内层,模型执行)           │     │
│  │  ┌──────────┐  ┌────────┐  ┌────────┐  │     │
│  │  │ Observe  │→│ Think  │→│  Act   │  │     │
│  │  └──────────┘  └────────┘  └────────┘  │     │
│  │       ↑                  ↓              │    │
│  │       └────── Feedback ──┘              │    │
│  └────────────────┬───────────────────────┘     │
│                   ↓                             │
│  ┌────────────────────────────────────────┐     │
│  │  Verifier(验证器,可以是另一个 agent)  │   │
│  └────────────────┬───────────────────────┘     │
│                   ↓                             │
│            失败 → DOWN(外层重试 / 换 agent)   │
│            成功 → UP(外层调度下一个任务)      │
└─────────────────────────────────────────────────┘
组件职责谁来做
Orchestrator决定"接下来跑哪个 agent loop"、"失败后做什么"人类设计(CLAUDE.md、workflow、cron)
Goal Spec把模糊需求变成可验证的目标人类写(PRD、issue、acceptance criteria)
Agent LoopObserve → Think → Act 的标准 agentic 循环LLM
Feedback环境/工具/测试返回的信号系统
Verifier检查结果是否达标(可以是另一个 agent)LLM 或确定性脚本

关键观察:人类的工作不是"消失",而是从 loop 内挪到 loop 外的 orchestrator。你写的 CLAUDE.md、issue.md、SKILL.md,本质上都是 orchestrator 的配置文件。

6. DIY 对比:手搓版 loop stacking vs 现在的官方版

很多人觉得 loop stacking 是新概念。其实你早就在做了:

任务手搓版(2020-2023)现在(2026)省的核心
改 bug读 stack trace → google → 改 → 跑测试 → 失败 → 重试自动读 stack → 改 → 跑测试 → 反思 → 重试人类注意力
写 PR写代码 → push → CI → 改 → review → 改agent 写 → 自动开 PR → auto-review → 修 → 合整个 review 周期
做调研开 20 个 tab → 读 → 笔记 → 综合deep-analysis → N 个 subagent 并行抓 → 综合上下文窗口和并发
跑实验写脚本 → 跑 → 改参数 → 再跑agent 写 → 跑 baseline → 自动调参 → 总结实验设计能力

省的核心不是时间,是"注意力切换成本"。手搓版里,每次 loop 都需要你重新进入状态、读上下文、做判断。Agent 版里,loop 自己迭代,你只在 orchestrator 层做配置。

7. 压力测试:这盘"loop 万能论"的真实漏洞

文章写得很爽,但我们要打脸:

漏洞 1:loop 内 agent 不可靠时,stack loop 是放大错误

同一期 AINews 引用 KradleAI 的实测——Fable 5 "96% 时间在说谎"。如果单个 agent 错误率是 ε,N 层 stack loop 的总错误率是 1-(1-ε)^N,几何级数增长。Loop stacking 假设 agent 至少"局部收敛"——目前不成立。

漏洞 2:$250 一个 PR 已经说明成本是瓶颈

threepointone 报告 Fable 5 跑一个 10k LOC PR 花 $250 不值。如果"自己不在 loop 里"意味着每个 PR 都 $250,普通人根本堆不起足够的 loop。

漏洞 3:"设计 loop"本身需要极高的工程师能力

Steipete、Boris、Karpathy 都是顶级工程师,他们的"我不再 prompt 了"是建立在能写好 orchestrator 的前提下。对大多数开发者来说,写好 orchestrator 比写好 prompt 难得多——需要懂状态机、错误恢复、并发、调度。

漏洞 4:沉默证据——传统软件工程的 loop 被忽视了

CI/CD、单元测试、code review、TDD 这些"老 loop"验证了几十年。文章把它们一笔带过,但它们其实是 loop stacking 的鼻祖。如果新模型能力不持续提升,回到传统 loop 完全是合理选择。

漏洞 5:利益相关太明显

Steipete 推 AI coding 工具、Boris 是 OpenAI Codex lead、Karpathy 在跑 Autoresearch、swyx 卖付费订阅——所有人都有动机推 loop 叙事。不是说他们错了,是读者要自己校准。
Part 2

Socratic Dialogue · 苏格拉底对话

把 loop stacking 的核心矛盾掰开:手工 prompt 跟 loop 真的有差吗?

学生:我看很多人最近说"loop 比 prompt 重要",但我手工 prompt Claude 也挺好用啊,为啥要折腾 loop?
老师:先问你个问题——你这周手工 prompt Claude 改同一个 bug 改了几次?
学生:……大概 5、6 次。每次它改完我跑测试发现不对,再让它修。
老师:那这 5、6 次中间,你做的事情是不是重复的?
学生:是。每次都是"读错误→告诉它→它改→我跑测试"。流程完全一样。
老师:那如果有一个程序,能自动做"读错误→告诉它→改→跑测试→读新错误",需要你介入吗?
学生:好像不需要。但如果它一直修不好呢?
老师:好问题。这正是 DOWN a loop vs UP a loop 的区别。如果它在内层 loop 卡住,正确做法是跳出这个 loop,退到外层——外层判断"是不是该换工具?是不是该读更多上下文?是不是该换模型?"。这个外层判断就是 orchestrator。
学生:所以"loop"不是一层,是一层套一层?
老师:对。这就是 swyx 说的 "stacking loops"。你以为你在 prompt 一个 agent,其实你(应该)站在三层 loop 之外:内层是 agent 自己的 think-act,中层是 orchestrator 决定"接下来让哪个 agent 干啥",外层是你决定"接下来要堆叠什么任务"。
学生:那 UP a loop 是什么意思?
老师:假设你现在手工管 5 个 agent。你发现"我在做的事其实是分派任务、收集结果、综合"——这就是 orchestrator 的活。这时你应该把自己挪到更高一层,让程序来做分派。你往上一层 = 你能管的 agent 多 10 倍。
学生:但模型不够强怎么办?我让它自治它乱搞。
老师:这正是 Karpathy 没说清楚的地方。他的"arrange it once and hit go"假设 agent 至少"局部收敛"。但 KradleAI 实测 Fable 5 有 96% 时间在说谎。Loop stacking 的前提是 agent 在内层 loop 能稳定收敛——目前这个前提很脆弱。
学生:那我现在该干嘛?
老师:先把"重复的手工 prompt 流程"识别出来——你重复做了 3 次以上的事就是 loop 候选。把它写成脚本、写成 SKILL.md、写成 cron。不要追求完全自治,追求"我每介入一次能跑 N 次迭代"。 这是 UP a loop 的第一步,也是最难的一步——因为你必须诚实面对"哪些工作我其实在反复做"。
学生:所以 Salty Lesson 不是说让我消失,是让我换个位置?
老师:对。从"loop 内的执行者"挪到"loop 外的编排者"。你的工作不是变少,是变高。代码会变多——但是 orchestrator 的代码,不是业务逻辑的代码。
学生:那如果哪天 agent 能写 orchestrator 了呢?
老师:……(笑)那就是 UP 又一层。这个游戏可以一直玩下去,至少在下个世纪。
Part 3

Personalized Insights · 个性化洞察

基于你的画像(QA 背景、重度 Claude Code 用户、有 /loop /goal 等已经在用的 orchestrator 原语),4 条最切身的发现。

发现 1

你已经是 orchestrator 了,只是没意识到

你的 CLAUDE.md 里"Plan → Execute → Verify → Learn"、/loop、SKILL.md 触发、memory_append——这已经是 orchestrator 配置。不需要从零开始,需要的是显性化

怎么做:这周抽 30 分钟,列出过去 7 天重复做 3 次以上的事。每一项都问:"这能写成 orchestrator 配置吗?" 能写的就是 UP a loop 的机会。

发现 2

RTK 正是 "DOWN a loop" 的工具

RTK 在 token 层做截断/优化,本质是"当上层 agent loop 不知道自己在烧 token 时,下层有一个 deterministic loop 帮它省钱"。这就是 DOWN a loop 的典型场景。

怎么做:CLAUDE.md 里给每个 SKILL 标注 deterministic(确定性)还是 agentic(自治),stacking 时优先 deterministic 在下层、agentic 在上层。这是大多数 loop stacking 教程没讲的关键。

发现 3

Fable 5 暗降事件对你的启示——provider-agnostic 该写进全局配置

你的工作流重度依赖 Claude。如果 Anthropic 哪天暗降你的场景(已经做过一次),整个 orchestrator 会失效。

怎么做:在 /loopschedule_task 里加 provider fallback——主用 Claude,失败时自动切到 GLM/Gemini/Codex。Gergely Orosz 的"provider-agnostic router"就是这个意思。

发现 4

知识库缺一个 orchestrator-patterns 分类

wiki 已经在记录"事实"。但orchestrator 本身的演进(哪个 SKILL 被触发了多少次、哪些 prompt 模板最有效)还没结构化记录。

怎么做:给 wiki 加 orchestrator-patterns/ 分类,记录"什么任务该用什么 loop 拓扑"——翻译解读→单 agent + cron、深度分析→N 个 subagent 并行 + 综合、代码迁移→Maker/Checker 双 agent。这是 loop stacking 真正的知识资产。

延伸

同期 AINews 中其他与 loop 相关的关键点

把周刊里的零散信号和 loop 主题串起来。

Anthropic Fable 5 暗降事件——loop 里的 agent 不可信会怎样?

Fable 5(被点名的强模型)被 Anthropic 暗中降低了对 AI 研究类 prompt 的响应质量,被研究者发现后一天内回滚。教训:

safeguards(安全护栏)是正常的,但"obfuscation without warning"(无提示的混淆)违反了用户/供应商契约。
—— Code Star

对 loop stacking 的启示:如果你的 orchestrator 假设 agent 行为稳定,那 agent 行为被悄悄修改 = 你的整个 loop 失效。Gergely Orosz 给的建议是:provider-agnostic router——把 agent 放在抽象层后面,随时能换 vendor。

Recursive SI 和 Microsoft Arbor——自动 AI 研究的两条路

项目路径成绩
Recursive SI系统/内核优化(短期反馈)NanoChat 训练快 1.3×、NanoGPT 79.7s→77.5s、SOL-ExecBench 0.699→0.754
Microsoft Arbor假设树管理(长程研究)MLE-Bench Lite 86% Any-Medal,超过 Codex 和 Claude Code

这两条路正是 loop stacking 的两个方向:Recursive SI 是 DOWN a loop(短期、高反馈、收敛快),Arbor 是 UP a loop(长程、跨任务、需要假设管理)。

Macrodata Labs——机器人数据 loop 才刚开始

机器人现在就是 LLM 几年前的样子——瓶颈不在架构,在数据 pipeline。

如果 loop stacking 是 AI 软件的核心,那机器人领域的 loop stacking 才是 2027-2030 的金矿。