🔁 Loop Engineering

Loop Engineering is replacing yourself with a system that prompts an agent. The "loop" can be thought of as a recursive goal — you define an intent, and AI iterates until it's done.

循环工程是用系统替代你自己去给 Agent 发指令。"循环"可以理解为一个递归目标——你定义一个目的，AI 迭代执行直到完成。

Peter Steinberger recently said: "You should stop manually prompting coding agents. You should design loops that prompt agents on your behalf." Boris Cherny, who leads Claude Code at Anthropic, said nearly the same thing: "I no longer prompt Claude myself. I have loops running that prompt Claude and decide what to do next. My job is to write loops."

Peter Steinberger 说："你不应该再手动给编程 Agent 写 prompt 了。你应该设计循环来替你给 Agent 发指令。" Claude Code 负责人 Boris Cherny 也说了几乎一样的话："我已经不亲自 prompt Claude 了。我的工作是写循环，它们给 Claude 发 prompt 并决定下一步。"

For the last two years, you've used coding agents by writing a good prompt with enough context. You type something, see what comes back, type the next thing. That phase is over — or at least, some people believe it's ending. Now you build a small system: it finds work on its own, dispatches tasks, checks results, records what's done, then decides what's next.

过去两年你写 prompt、贴上下文、敲一段看回复再敲下一段。这个阶段正在结束。现在你构建一个小系统：它自己找活干、分发任务、检查结果、记录进度、决定下一步。

Loop Engineering sits one layer above Harness. Harness plus a timer, plus the ability to spawn helpers, plus the ability to feed itself — that's a Loop. What surprises me is that this is no longer a tool-level challenge. A year ago you'd write bash scripts and maintain them forever. Now the components ship built into products.

Loop Engineering 在 Harness 上面一层。Harness + 定时器 + 能 spawn 帮手 + 能自己喂自己 = Loop。让我惊讶的是这已不再是工具层面的事。一年前你写一堆 bash 脚本自己维护，现在这些组件内建在产品里。

A loop needs five things, plus a place to remember:

1. Automations — trigger on a schedule, do discovery and triage by themselves.
2. Worktrees — let two agents work in parallel without stepping on each other's files.
3. Skills — write project knowledge down once so the agent doesn't guess every time.
4. Plugins & Connectors — connect agents to the tools you already use.
5. Sub-agents — one proposes ideas, another checks them.

Then the sixth: Memory. A Markdown file, a Linear board — anything that lives outside a single conversation. Models forget everything between runs, so memory must be on disk. Agents forget, repos don't.

一个循环需要五样东西，再加记忆：

1. 自动化——按计划触发，自己发现+分诊。
2. 工作树——并行 Agent 互不踩脚。
3. 技能——项目知识写一次，不等 Agent 每次猜。
4. 插件和连接器——接入你已有的工具。
5. 子 Agent——一个出主意，一个检查。

第六样：记忆。Markdown 文件或 Linear 看板——单次对话之外的东西。模型在每次运行之间遗忘一切，所以记忆必须落盘。Agent 会忘，仓库不会。

Both products now have all five. Automations: scheduled discovery + triage. Worktrees: isolate parallel features. Skills: crystallize project knowledge with SKILL.md. Plugins/Connectors: MCP-based. Sub-agents: defined in .codex/agents/ or .claude/agents/. State: Markdown or Linear.

两个产品都有了全部五样。自动化：定时发现+分诊。工作树：隔离并行。技能：SKILL.md 固化项目知识。插件/连接器：基于 MCP。子 Agent：TOML 或 YAML 定义。状态：Markdown 或 Linear。

Automation: The heartbeat. Automation makes a loop a loop, not just something you ran once. OpenAI uses this internally — daily issue triage, summarizing CI failures, writing commit digests, tracking who wrote a bug last week. Automations can call skills, so you factor the maintainable loop into a $skill-name instead of pasting a wall of instructions into a scheduler nobody updates.

自动化：这是心跳。自动化让循环成为真正的循环。OpenAI 内部用它做日常——每日 issue 分诊、汇总 CI 失败、写 commit 简报、追踪谁写了个 bug。自动化可以调用 skill，把可维护的循环抽成 $skill-name，而不是把一堵指令墙贴进调度器，永远没人更新。

/goal: Run until done. /loop repeats on a frequency. /goal keeps running until a condition you write is true — a separate small model checks whether you're done, so the coding agent isn't grading its own work. You give it "all tests/auth pass and lint is clean" and walk away. Codex has the same, also called /goal. Same primitive, both tools.

/goal：跑完为止。/loop 是按频率重复，/goal 是跑到条件为真才停——独立小模型检查你是否完成，写代码的 Agent 不给自己的作业打分。给它"test/auth 全过且 lint 干净"然后走开。两个工具都有同一个原语。

Worktrees: Parallel without collision. Two agents writing to the same file is as painful as two engineers committing to the same line without talking. Git worktree solves this — an independent working directory on its own branch. Codex has built-in worktree support; Claude Code gives --worktree and isolation: worktree on sub-agents.

工作树：并行不翻车。两个 Agent 写同一个文件 = 两个工程师没沟通往同一行 commit。Git worktree 解决——独立工作目录独立分支。Codex 内建支持，Claude Code 用 --worktree 和 isolation: worktree。

Skills: Don't re-explain your project every time. A skill is project context you'd otherwise re-teach in every session. Both tools use SKILL.md. Skills are also where intent stops being re-spent — the agent cold-starts from zero every session and fills gaps with confident guesses. A skill inscribes that intent externally. Without skills, the loop re-derives your project each cycle from scratch; with skills, it compounds.

技能：别每次都重新解释你的项目。Skill = 每次会话要重讲的项目上下文固化下来。两个工具都用 SKILL.md。Skill 也是 Intent Debt（意图债务）的解法——Agent 每次从零冷启动，用自信猜测填补空白。Skill 把这些意图写在外面。没有 skill，循环每个周期从零推导；有了 skill，它会叠加。

Plugins & Connectors: The loop touches your real tools. Connectors — built on MCP — let an agent read your issue tracker, query databases, hit staging APIs, send Slack messages. Both tools speak MCP. This is the gap between "the agent says here's a fix" and "the loop opens a PR, links the Linear ticket, CI goes green, and the channel gets pinged."

插件和连接器：循环触碰你的真实工具。基于 MCP 的连接器让 Agent 读 issue tracker、查数据库、打 staging API、发 Slack。两个工具都说 MCP，你为一个写的另一个通常也能用。这就是"Agent 说这里有修复"和"循环自己开 PR、关联 ticket、CI 绿了自动通知"之间的差距。

Sub-agents: Separate the writer from the checker. The coding model is too generous with its own homework. A second agent, with different instructions and sometimes a different model, catches what the first talks itself into. Common division of labor: one explores, one implements, one verifies against spec.

子 Agent：把写的和查的分开。写代码的模型对自己的作业太宽容了。第二个 Agent——不同指令，有时不同模型——能抓住第一个自圆其说的东西。常见分工：一个探索、一个实现、一个拿 spec 验证。

A complete loop: An automation runs on the repo every morning, calling a triage skill that reads CI failures, open issues, recent commits — writing findings into a Markdown file or Linear board. For each finding worth addressing, it opens a worktree, dispatches a sub-agent to draft a fix, dispatches a second to review. Connectors let the loop open PRs and update tickets. What it can't handle lands in the Triage inbox. You designed once. You didn't write a prompt for any step.

一个完整循环：每天早上自动化在仓库上跑，调用 triage skill 读 CI 失败/open issue/最近 commit，写入 Markdown 或 Linear。对每个值得处理的发现——开独立工作树→派子 Agent 起草修复→派第二个审查。连接器开 PR、更新 ticket。处理不了的进 Triage 收件箱等你。你设计了一次。没有给任何步骤写 prompt。

Loops change how you work, but they don't delete you. Three problems get sharper the more capable loops become:

1. Verification is still yours. "Done" is a claim, not a proof.

2. Your understanding will still rot. The faster a loop ships code you didn't write, the bigger the gap between what exists and what you comprehend — Comprehension Debt.

3. The most comfortable posture is the most dangerous. When a loop runs itself, it's easy to stop having opinions — Cognitive Surrender. Designing loops with judgment is the antidote; doing it to avoid thinking is the accelerator — same action, opposite outcome.

循环改变了工作方式，但不能删掉你。三个问题随循环变强而更尖锐：

1. 验证仍然是你的事。"做好了"是声明不是证明。你的工作是交付确认能工作的代码。

2. 你的理解仍然会腐烂。循环越快交付你没写的代码，存在的代码和你理解之间的差距越大——Comprehension Debt。

3. 最舒服的姿势最危险。循环自己跑起来，你很容易停止有主见——Cognitive Surrender。带着判断力设计是解药，逃避思考是加速器——同一动作，相反结果。

Build loops. Stay an engineer. Two people can build identical loops and get opposite results. One uses it to accelerate work they deeply understand; the other uses it to avoid understanding the work at all. The loop doesn't know the difference. You do. Cherny's point isn't that the work got easier — it's that the leverage point moved. Build loops, but build them like someone who intends to stay an engineer — not just the person who presses start.

搭建循环。保持工程师身份。两个人搭完全相同的循环，得到完全相反的结果。一个加速深度理解的工作；另一个逃避理解工作。循环不知道区别。你知道。Cherny 的观点不是工作变容易了——是杠杆支点移动了。搭循环，但像个打算保持工程师身份的人那样去搭——而不只是按"开始"的人。