循环（Loops）：2026 年每位 AI 工程师都必须掌握的知识

Peter Steinberger 是 OpenClaw 的创始人，现在与 OpenAI 合作。

昨天他发布了这样一段话：

“你不再应该给编程智能体（coding agent）写提示词了。你应该设计循环（loop）来给你的智能体下达提示。”

随后，Anthropic 公司 Claude Code 的负责人 Boris Cherny 用不同的方式表达了同样的观点：

“我不再给 Claude 写提示词了。我在运行循环，让循环来提示 Claude 并决定下一步做什么。我的工作就是编写这些循环。”

两位顶级 AI 工程师，同一个信息。

大多数人看到这话，心里想的是：这到底是什么意思？

我深入探究了一下。

下面就把所有内容——简单拆解开来。

没有行话。你只需要理解这个思维模型。

收藏好。它会改变你对 AI 的看法。

但首先：大多数人从未构建循环的原因

循环听起来很棒。然后你就看到了账单。

这是没人会提前告诉你的实话。

一个中等编码任务的单智能体循环：50,000–200,000 个 token。

一个带有编排器和 3 个专家的舰队循环：500,000–2,000,000 个 token。

一个每天早上按计划运行的循环：每周数百万个 token。

按照标准的 API 定价，一周认真的循环工程，花费比大多数人整个月的 AI 预算还高。

这就是为什么 Peter Steinberger 的回复里，有大量的人说：

“你说得轻巧——你有无限使用 OpenAI 的权限。”

他们说的没错。

在普通预算下进行循环工程，很快就会超支。

每次重试都要花钱。每次自我修正都要花钱。每个子智能体都要花钱。每次验证通过都要花钱。

那个自由探索的开放循环？消耗 token 的速度快得让你心疼。

这就是没人提及的隐藏障碍。

设计循环并不难。

难的是付得起这个费用。

而这正是中国的大语言模型（LLM）解决的问题。

像 DeepSeek、Kimi 和 MiniMax 这样的模型，让智能体循环在经济上变得可行。

自主智能体最大的问题不是智能。

而是 token 消耗。

循环消耗 token 非常快。

单次运行就可能轻易消耗 50K–200K 个 token。

如果运行多个智能体，每日按计划执行循环，或者处理大型代码库——成本会迅速飙升。

这时 DeepSeek 改变了游戏规则。

DeepSeek V4 是目前 大规模运行循环性价比最高的前沿模型之一。

你能获得什么：

→ 100 万上下文窗口 —— 专为大型项目和长时工作流设计

→ 38.4 万最大输出 —— 无需中断即可处理更大的生成任务

→ DeepSeek V4 Flash + Pro 模型

→ 极低的 token 定价

→ 支持工具调用 + JSON 输出，适用于智能体工作流

→ 高并发能力（Flash 版本最高支持 2500 个请求）

为什么 100 万上下文窗口如此重要：

循环需要记忆。

处理大型项目的编码循环需要同时记住：

— 之前的运行结果

— 当前的错误信息

— 架构文档

— 测试结果

— 代码库上下文

大多数模型中途会丢失上下文。

你的循环会忘记之前发生的事情。

DeepSeek 能承载更多的上下文，因此长时间运行的循环能保持连贯性。

而且因为定价非常低：

循环不再让你破产。

第一部分：旧方法 vs. 新方法

过去两年，我们每次都是为一个任务给智能体写提示词。

你输入一个提示词。智能体做出回应。你检查结果。你修正错误。你再输入提示词。你就是那个循环。

这种情况正在改变。

你不再需要指示一个智能体去构建一个落地页，然后亲自推动每一步；而是建立一个循环，让它负责发现、规划、执行、检查和迭代，直到目标达成。

区别在于：

旧方法（提示词）：

你 → 提示词 → 智能体 → 输出 → 你审查 → 你修正 → 重复

新方法（循环）：

你设定目标 → 循环运行 → 智能体发现 → 规划 → 执行 → 验证 → 迭代 → 完成

你不再需要为每一步提供提示。

智能体为你重复这个循环。

一条提示词给智能体指令。

一个循环给智能体一份工作。

第二部分：循环工程到底是什么

循环工程（Loop Engineering）是一种实践，旨在设计可重复的反馈循环，引导 AI 智能体从尝试出发，最终产出经过验证的结果——期间无需持续的人工干预。

循环是你构建的一个设置。

几乎任何智能体工具都能运行它。

关键在于你如何将它们连接起来。

最简单的形式是，一个智能体自我改进：

→ 研究

→ 起草

→ 对照目标检查草稿

→ 修正薄弱环节

→ 重复此循环，直到成果达到要求

每个循环——无论简单还是复杂——都经过

相同的 5 个阶段：

发现 → 规划 → 执行 → 验证 → 迭代

通过验证 → 交付。

未通过验证 → 再次循环。

这就是全部理念。

本文中其他所有内容，都只是告诉你如何正确地构建这个循环。

第三部分：单智能体 vs. 舰队

循环有两种规模：

单智能体循环

一个智能体单独运行整个循环。

可以把它想象成一个人反复修改自己的稿件。

它发现需要什么，规划工作，执行，检查质量，如果有问题就进行迭代。

适用于：

→ 聚焦型任务

→ 简单的目标

→ 有限的范围

一个大脑。一个循环。自我改进。

━━━

舰队循环

更大规模的版本是舰队循环。

你给一个编排智能体设定一个目标。

它将目标分解成若干部分。

把每个部分交给一个专家智能体。

这些专家再把更小的任务交给它们自己的子智能体。

整个树状结构持续经历发现、规划、执行和验证的循环——直到达成目标。

可以把它想象成一个完整的团队端到端地运行一个项目。

其结构如下：

→ 编排器掌管目标

→ 专家掌管步骤

→ 子智能体执行具体工作

→ 评估关卡确保质量

例子：“构建一个生产力应用”

编排器（掌管任务） ↓ ↓ ↓ 研究专家 工程专家 QA 专家 ↓ ↓ ↓ 网页研究员 代码编写员 + 测试编写员 + 调试员 错误追踪员

树中的每个智能体都运行相同的 5 阶段循环。

发现 → 规划 → 执行 → 验证 → 迭代。

重要的是：

单智能体循环就像一个反复修改自己稿件的人。

舰队循环就像一个完整的团队端到端地运行一个项目。

第四部分：开放循环 vs. 封闭循环

这是 2026 年最重要的实际区别：

并非所有循环都平等。

有两种类型。

开放循环

探索性。行动空间广阔。

你给智能体一个目标，让它自由探索。

它可以尝试不同的路径，发现新事物，构建你未完全指定规格的东西。

这是令人兴奋的一面。也是 Peter Steinberger 和其他人在 OpenAI 所做的。

问题在于？

它会消耗数量惊人的 token。

对于 90% 没有无限 API 预算的人来说，开放循环目前还不实用。

如果用于标准宽松的项目，它会变成一个产生废料的机器。

快速。混乱。昂贵。

封闭循环

有界。人类首先设计端到端的路径。

→ 明确的目标

→ 定义的步骤

→ 每一步都有评估

→ 一个停止点或交回给你控制的点

智能体仍然循环——但在你构建的框架内。

每次运行都会变得更好，因为每次通过都会为下一次提供输入。

它在正常预算下运行，因为路径是紧凑的。

标准确保诚实。

没有质量关卡：AI 会偏离轨道。

有了质量关卡：AI 会改进。

对于当今大多数实际工作来说，封闭循环是能带来回报的那一种。

你应该用哪一种？

从封闭循环开始。

构建一个运行可靠的紧凑系统。

然后，一旦你有了质量关卡，再将其开放。

第五部分：每个良好循环的 6 个构建模块

每个稳固的循环都包含这 6 个要素：

现在是实际部分。

一个循环在概念上有 5 个阶段。

但你需要实际构建什么来让它运行呢？

6 个要素。Claude Code 和 Codex 现在都包含了所有这些。

以下是它们——以及每个在循环内部真正做的事情。

1. 自动化

这是触发“发现”阶段并启动循环的机制。

循环的心跳。

自动化是让一个循环成为真正循环的关键——而不仅仅是你做了一次的单次运行。

你定义一个提示词、一个节奏和一个目标。

循环按计划运行。发现结果会呈现给你。你不需要自己去检查。

→ /loop 按节奏重新运行

→ /goal 持续运行，直到你编写的条件真的成立

设定为：“test/auth 中的所有测试都通过，并且 lint 检查是干净的。”

然后走开。

2. 工作树

这使得多个“执行”阶段能够并行运行而不相互干扰。

并行智能体，无需混乱。

一旦你运行超过一个智能体，文件就会开始冲突。

两个智能体写入同一个文件，就像两个工程师在不沟通的情况下提交到同一行代码一样。

git 工作树为每个智能体提供自己独立的工作目录，在自己的分支上——共享相同的仓库历史，零冲突。

一个智能体的编辑实际上不可能触及另一个智能体的检出内容。

3. 技能

这使得“发现”阶段更快——智能体在开始之前就已经了解你的项目。

不必每次运行都从头开始解释你的项目。

一个技能是一个包含 SKILL.md 的文件夹——项目约定、构建步骤、“我们从不这样做，因为发生过那次事故”。

写一次。每个循环都读取。

没有技能：循环每次都会从零重新推导你的整个项目。

有技能：知识会累积。智能体在开始前就已经了解你的项目。

→ VISION.md —— 成功是什么样的

→ ARCHITECTURE.md —— 技术栈和文件夹结构

→ RULES.md —— 智能体绝不能做的事情

4. 插件和连接器

这使得“执行”阶段变得真实——循环在你的实际环境中行动，而不仅仅在你的文件系统中。

一个只能看到文件系统的循环是一个很小的循环。

连接器（基于 MCP）让智能体读取你的问题追踪器、查询数据库、访问测试 API、在 Slack 中发送消息。

这就是一个只会说“这是修复方案”的智能体，与一个能自动打开 PR、关联 Linear 工单，并在 CI 通过后自动通知频道的循环之间的区别。

5. 子智能体

这使得“验证”阶段变得诚实——检查者永远不会与制造者是同一个智能体。

让制造者远离检查者。

编写代码的模型在批改自己的作业时会过于宽容。

第二个具有不同指令的智能体——有时是不同的模型——会捕捉到第一个智能体自己说服自己忽略的问题。

行之有效的分工：

→ 一个智能体负责探索

→ 一个智能体负责实现

→ 一个智能体负责对照规格进行验证

这也是 /goal 在幕后所做的。

一个全新的模型决定循环是否完成——而不是那个完成工作的模型。

6. 记忆

这使得循环能够持久化——“发现”阶段在第 47 次运行时知道第 1 到第 46 次运行已经尝试过什么。

整个循环的支柱。

一个 Markdown 文件。一个 Linear 看板。任何存在于单次对话之外的东西。

模型会忘记每次运行之间的所有内容。

仓库不会。

记忆文件保存了：尝试过什么、通过了什么、还有什么未完成。

明天早上，循环会从今天停止的地方继续。

听起来太简单了，以至于觉得不重要。

每个长时间运行的循环都依赖它。

第六部分：真实的循环示例

循环在实践中是什么样子：

编码循环

1读取 VISION.md + ARCHITECTURE.md
2↓
3规划下一个更改
4↓
5编辑代码
6↓
7自动运行测试
8↓
9如果测试失败 → 读取错误 → 修复 → 重新测试
10↓
11如果测试通过 → 总结更改
12↓
13停止

中间没有人工干预。

智能体自行编写、测试、修复和验证。

━━━

研究循环

1定义研究问题
2↓
3搜索来源
4↓
5总结发现
6↓
7对照来源验证声明
8↓
9比较冲突信息
10↓
11综合最终答案
12↓
13达到置信度阈值后停止

━━━

内容循环

1定义主题 + 受众 + 目标
2↓
3创建草稿
4↓
5评论智能体审查草稿
6↓
7根据评论重写
8↓
9对照成功标准评分
10↓
11如果分数通过 → 发布
12↓
13如果分数未通过 → 再次重写

━━━

销售推广循环

1定义 ICP（理想客户画像）
2↓
3寻找匹配画像的潜在客户
4↓
5用公司数据丰富信息
6↓
7对照标准进行资格认定
8↓
9个性化信息
10↓
11质量审查
12↓
13发送或升级给人工处理

每个循环都有相同的骨架：

目标 → 行动 → 检查 → 修正 → 重复直到完成。

第七部分：提示词工程师 vs. 循环工程师

2026 年正在拉开的技能差距：

提示词工程师

→ 编写更好的指令

→ 语言技能

→ 更好的提示词

→ 更好的单次输出

→ 仍然在每次运行后手动检查输出

→ 你就是反馈循环

循环工程师

→ 设计更好的反馈循环

→ 软件工程技能

→ 更好的循环

→ 可靠且经过验证的结果

→ 系统运行、检查和自我修正

→ 系统本身就是反馈循环

提示词工程师 -> “帮我写一个函数”

循环工程师 -> “编写 → 测试 → 修正直到通过”

编写更好的提示词 编写 VISION.md 手动检查输出 自动验证测试 单次运行智能体 构建重复系统 为单次输出付费 为验证后的结果付费

工具是一样的。

思维方式完全不同。

提示词工程师向 AI 索取输出。

循环工程师设计能够产生经过验证结果的系统。

2026 年收入最高的 AI 工程师，不是那些会写更好英文句子的人。

而是那些编写逻辑，来决定智能体如何发现、规划、检查自己工作，以及知道何时完成任务的人。

结语

以上就是循环工程。

让我总结一下所有内容：

转变：

→ 两年来，我们每次为一个任务给智能体写提示词 → 现在我们设计循环来运行整个周期

你实际构建的 6 个要素：

→ 自动化——心跳，触发发现

→ 工作树——并行智能体，无冲突

→ 技能——每次运行都会累积的项目知识

→ 插件和连接器——循环在你的真实工具中行动

→ 子智能体——制造者和检查者不是同一个智能体

→ 记忆——循环在运行之间不会遗忘

两种规模：

→ 单智能体：一个大脑，自我改进

→ 舰队：编排器 + 专家 + 子智能体——每个智能体运行相同的循环

两种类型：

→ 开放循环：探索性，强大，昂贵，需要无限预算

→ 封闭循环：有界，可靠，经济实惠，当今能带来回报的那一种

每个良好循环的 5 个部分：

→ 目标——精确定义“完成”意味着什么

→ 上下文——VISION.md, ARCHITECTURE.md, RULES.md

→ 行动——只包含智能体实际需要的内容

→ 反馈——测试、类型检查、linter、结构化错误

→ 停止条件——当循环知道自己已完成时

成本问题：

→ 循环消耗 token 非常快

→ 20 美元在 DeepSeek 上能走的路程，比大多数前沿模型远得多

→ 这消除了最后一个真正的障碍

重大转变：

→ 提示词工程师向 AI 索取输出

→ 循环工程师设计能够产生经过验证结果的系统

Peter Steinberger 说得对：

不要再给你的智能体写提示词了。

开始设计循环。

因为一个可靠的循环，抵得上一千个完美的提示词。

还有一件没人明说的事。

两个人可以构建完全相同的循环，却得到截然相反的结果。

一个人用它来在自己深刻理解的工作上更快地推进。

另一个人用它来避免去理解工作本身。

循环不知道这其中的区别。

你知道。

这就是为什么循环设计比提示词工程更难——而不是更容易。

Boris Cherny 的观点不是工作变得更容易了。

而是杠杆点转移了。

构建这个循环。

但要像打算一直做那个工程师（而不是仅仅按下启动键的人）一样去构建它。

因为一个可靠的循环，抵得上一千个完美的提示词。

而且有了 20 美元 17 亿个 token 的价格，你终于有能力构建一个了。

如果这篇文章对你有帮助：

→ 转发分享给你的朋友

→ 关注 @sairahul1 获取更多类似的深度解析

→ 收藏此文——这 5 部分框架值得反复翻阅

我写关于 AI、产品构建，以及那些在你睡觉时也能运行的系统。