Loop engineering is replacing yourself as the person who prompts the agentLoop Engineering循环工程让系统替你向 Agent 发出 Prompt翻译说明英文原文在上中文译文在下。本文面向 AI 技术读者。为兼顾技术准确性与中文可读性产品名称、命令、文件名以及行业中通常保留英文的术语如Agent、Token、Prompt、MCP、Git worktree和agent harness保留英文需要解释的术语在首次出现时采用“英文术语中文释义”的形式。其他词语根据语境译为自然中文避免机械式中英文混排并确保同一术语在全文中保持一致。Loop engineering means replacing yourself—the person who prompts the agent—with a system that does it instead. A loop can be thought of as a recursive goal: you define a purpose, and the AI iterates until the goal is complete. I believe this may be the future of how we work with coding agents. However, it is still early, and I remain skeptical. You absolutely have to be careful about token costs, because usage patterns can vary wildly when your token budget is abundant or constrained. So I want to unpack what loop engineering is and what it means.Loop Engineering循环工程的核心是用一套系统替代“亲自向 Agent 发出 Prompt 的人”让系统来完成这件事。这里的“循环”可以理解为一种递归目标你定义目的AI 持续迭代直到目标完成。我认为这可能会成为未来我们与 Coding Agent 协作的方式。不过现在下结论还为时尚早我仍然持怀疑态度。你必须特别注意 Token 成本因为当 Token 预算宽裕或紧张时使用方式可能会截然不同。所以我想具体拆解一下循环工程是什么以及它意味着什么。Peter Steinberger recently said: “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.” Similarly, Boris Cherny, head of Claude Code at Anthropic, said: “I don’t prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops.”Peter Steinberger 最近说“你不应该再亲自给 Coding Agent 编写 Prompt 了。你应该设计能够自动向 Agent 发出 Prompt 的循环。”类似地Anthropic 的 Claude Code 负责人 Boris Cherny 说“我已经不再亲自给 Claude 写 Prompt 了。我运行的是那些会向 Claude 发出 Prompt、并判断下一步该做什么的循环。我的工作就是编写循环。”Okay, so what does any of that mean?好吧这些话到底是什么意思For roughly two years, the way you got something out of a coding agent was to write a good prompt and share enough context. You typed something, read what came back, and typed the next thing. The agent was a tool, and you held it the entire time, one turn after another. That phase is probably coming to an end—or at least some people think it is.过去大约两年里如果你想从 Coding Agent 那里得到结果通常要写出一个好的 Prompt并提供足够的上下文。你输入一段内容阅读返回的结果再输入下一段内容。Agent 是一个工具而你始终亲手操作着它一轮接一轮地推进。这个阶段或许正在走向终点——至少有些人是这样认为的。Now you build a small system that finds the work, hands it out, checks it, records what is done, and then decides what comes next. You let that system drive the agents instead of doing the driving yourself. I have written before about two related ideas: agent harness engineering, which makes the environment a single agent runs inside, and the factory model, the system that builds the software. Loop engineering sits one floor above the harness. You can think of it as the harness running on a timer: it spawns small helpers and feeds itself.现在你要构建的是一个小型系统它识别待处理任务、分派任务、检查结果、记录已完成事项然后决定下一步做什么。你让这个系统去驱动 Agent而不是由你亲自驱动。我之前写过两个相关概念一是 agent harness engineeringAgent 运行框架工程也就是构建单个 Agent 运行于其中的环境二是 factory model工厂模型也就是负责构建软件的系统。循环工程位于 agent harness 的上一层。你可以把它理解为一个定时运行的 agent harness它会创建小型辅助 Agent并不断为自己提供后续任务。What surprised me is that this is no longer really a tool-specific problem. A year ago, if you wanted a loop, you wrote a pile of Bash scripts and maintained that pile forever. It was yours, and only yours. Now the pieces ship inside the products. Steinberger’s list maps almost exactly onto the Codex app, and almost as closely onto Claude Code. Once you notice that the shape is the same, you stop arguing about which tool to use. You design a loop that keeps working no matter which tool you happen to be using.让我感到意外的是这已经不再是某个特定工具的问题了。一年前如果你想构建一个循环就得写一大堆 Bash 脚本并且一直维护下去那套东西只属于你也只有你能用。如今这些组件已经直接集成在产品中。Steinberger 列出的内容几乎可以与 Codex 应用一一对应也几乎同样适用于 Claude Code。一旦你发现它们的结构相同就不会再纠结应该使用哪个工具而是会设计一个无论运行在哪种工具中都能持续工作的循环。The five pieces, and then a place to remember things五个组成部分以及一个保存记忆的地方A loop needs five things, and then one place to remember things. Let me list them first and then map them.一个循环需要五个组成部分另外还需要一个用于保存记忆的地方。我先把它们列出来再说明它们如何对应。Automationsthat run on a schedule and perform discovery and triage by themselves.Worktreesso two agents working in parallel do not step on each other.Skillsthat record project knowledge the agent would otherwise have to guess.Plugins and connectorsthat plug the agent into the tools you already use.Sub-agentsso one of them can develop an idea and another can check it.Automations自动化按计划运行自主完成任务发现和分类处理。Worktrees工作树让两个并行工作的 Agent 不会互相干扰。Skills技能记录项目知识避免 Agent 只能依靠猜测。Plugins and Connectors插件与连接器把 Agent 接入你已经在使用的工具。Sub-agents子 Agent让一个 Agent 提出方案另一个 Agent 负责检查。Then there is the sixth thing: memory. It can be a Markdown file, a Linear board, or anything else that lives outside a single conversation and records what is done and what comes next. It sounds too simple to matter, but it is the same trick every long-running agent depends on. As I discussed in long-running agents, the model forgets everything between runs, so the memory has to live on disk rather than in the context. The agent forgets; the repo does not.然后是第六样东西记忆。它可以是一个 Markdown 文件也可以是一个 Linear 看板任何存在于单次对话之外、能够记录“已经完成什么”和“接下来要做什么”的东西都可以。它听起来简单得似乎无关紧要但每个长期运行的 Agent 都依赖这个技巧。正如我在《Long-running Agents长期运行的 Agent》中讨论的那样模型会忘记不同运行之间发生的一切因此记忆必须保存在磁盘上而不能只存在于上下文中。Agent 会忘记但代码仓库不会。Both products now have all five core pieces.现在这两款产品都已经具备这五个核心组成部分。PrimitiveJob in the loopCodex appClaude CodeAutomationsDiscovery and triage on a scheduleAutomations tab: choose the project, prompt, cadence, and environment; results land in a Triage inbox;/goalruns until doneScheduled tasks and cron,/loop,/goal, hooks, and GitHub ActionsWorktreesIsolate parallel featuresBuilt-in worktree per threadgit worktree,--worktree, andisolation: worktreeon a sub-agentSkillsCodify project knowledgeAgent Skills (SKILL.md), invoked with$nameor implicitlyAgent Skills (SKILL.md)Plugins / connectorsConnect your toolsConnectors through MCP, plus plugins for distributionMCP servers plus pluginsSub-agentsIdeate and verifyDefined as TOML files in.codex/agents/Task subagents in.claude/agents/and agent teamsStateTrack what is doneMarkdown or Linear through a connectorMarkdown (AGENTS.md, progress files) or Linear through MCPPrimitive基础组件在循环中的作用Codex 应用Claude CodeAutomations按计划发现任务并进行分类处理Automations 标签页选择项目、Prompt、执行频率和运行环境结果进入 Triage 收件箱/goal持续运行直至完成定时任务、cron、/loop、/goal、hooks 和 GitHub ActionsWorktrees隔离并行开发的功能每个任务都有内置 worktreegit worktree、--worktree以及 Sub-agent 的isolation: worktreeSkills将项目知识固化下来Agent SkillsSKILL.md通过$name或隐式调用Agent SkillsSKILL.mdPlugins / connectors连接你使用的工具基于 MCP 的 Connectors以及用于分发的 PluginsMCP servers 和 PluginsSub-agents构思并验证在.codex/agents/中以 TOML 文件定义.claude/agents/中的任务型 Sub-agents 和 Agent TeamsState跟踪已经完成的事项Markdown或通过 Connector 接入 LinearMarkdownAGENTS.md、进度文件或通过 MCP 接入 LinearThe names differ slightly here and there, but the capability is essentially the same. Let me go one by one, because the details are what determine whether a loop holds together or quietly leaks problems everywhere.两边使用的名称略有不同但能力本质上是一样的。下面逐项说明因为细节决定了一个循环能否稳定运行还是会在不知不觉中到处出现漏洞。Automations: the heartbeat of the loopAutomations循环的心跳Automations are what make a loop an actual loop rather than a single run you performed once. In the Codex app, you create one in the Automations tab and choose the project, the prompt it will run, how often it runs, and whether it runs on your local checkout or in a background worktree. Runs that find something go to a Triage inbox; runs that find nothing simply archive themselves, which is useful. OpenAI uses them internally for boring work such as daily issue triage, summarizing CI failures, writing commit briefings, and hunting bugs someone introduced last week. An automation can also call a skill, so recurring work stays maintainable: you trigger$skill-nameinstead of pasting a giant wall of instructions into a schedule that nobody will ever update.Automations 让循环真正成为循环而不只是你运行过一次的单次任务。在 Codex 应用中你可以在 Automations 标签页创建一项 Automation并选择项目、要运行的 Prompt、运行频率以及它是在本地检出目录还是后台 Git worktree 中运行。发现问题的运行结果会进入 Triage 收件箱没有发现问题的运行则会自动归档这很实用。OpenAI 内部会用它们处理一些枯燥工作例如每日 issue 分流、汇总 CI 失败、编写提交简报以及追查上周有人引入的 bug。Automation 还可以调用 Skill因此重复性工作能够保持可维护你只需触发$skill-name而不必把一大段永远没人更新的说明粘贴到计划任务中。Claude Code reaches the same destination through scheduling and hooks. You can run a prompt or command at an interval with/loop, schedule a cron task, fire shell commands at specific points in the agent lifecycle with hooks, or push the whole thing to GitHub Actions if you want it to keep running after you close the laptop. The idea is exactly the same: define an autonomous task, give it a cadence, and have the findings come to you instead of going around checking everything yourself.Claude Code 通过调度和 hooks 实现同样的目标。你可以用/loop按固定间隔运行 Prompt 或命令可以安排 cron 任务可以通过 hooks 在 Agent 生命周期的特定节点触发 shell 命令如果希望关闭笔记本电脑后仍继续运行还可以把整个流程交给 GitHub Actions。思路完全相同定义一个自主任务为它设置执行频率然后让发现结果主动送到你这里而不是由你亲自到处检查。There is another in-session primitive worth knowing, and it is closer to what this whole post is about./loopreruns on a cadence./goalkeeps going until a condition you wrote is actually true. After every turn, a separate small model checks whether the work is done, so the agent that wrote the code is not the one grading it. You might give it a condition such as “all tests intest/authpass and lint is clean” and walk away. Codex has the same feature, also called/goal: it keeps working across turns until a verifiable stopping condition holds, with pause, resume, and clear status feedback. The same primitive exists in both tools, which is a pattern for this whole article.还有一个值得了解的会话内原语它更接近本文的核心主题。/loop会按照设定的频率重复运行/goal则会持续运行直到你写下的条件真正成立。每个回合结束后都会由另一个独立的小模型检查任务是否完成因此编写代码的 Agent 并不会给自己打分。你可以给它设定类似“test/auth中的所有测试都通过并且 lint 检查无误”这样的条件然后直接离开。Codex 也有同样的功能同样称为/goal它会跨多个回合持续工作直到一个可验证的停止条件成立并支持暂停、恢复和清晰的状态反馈。同一个原语同时存在于两款工具中这正是本文整体模式的缩影。This is the part that surfaces the work. The rest of the loop is what acts on it.这部分负责把待处理的工作呈现出来循环的其余部分则负责采取行动。Worktrees: so parallel work does not turn into chaosWorktrees避免并行工作变成混乱The moment you run more than one agent, the files start colliding, and that becomes the failure mode. Two agents writing to the same file create exactly the same headache as two engineers committing to the same lines without talking to each other first. A Git worktree fixes this: it is a separate working directory on its own branch that shares the same repository history, so one agent’s edits literally cannot touch the other agent’s checkout.当你同时运行多个 Agent 时文件很快就会发生冲突而这会成为一种失败模式。两个 Agent 修改同一个文件就像两个工程师事先没有沟通却向相同代码行提交修改一样令人头疼。Git worktree 可以解决这个问题它是在独立分支上创建的独立工作目录同时共享同一个代码仓库历史因此一个 Agent 的修改实际上不会触碰另一个 Agent 的工作副本。Codex builds worktree support in, so several threads can work on the same repo at once without bumping into one another. Claude Code gives you the same isolation withgit worktree, a--worktreeflag to open a session in its own checkout, and anisolation: worktreesetting on a sub-agent so each helper gets a fresh checkout that cleans itself up afterward. I wrote about the human side of this in the orchestration tax: worktrees remove the mechanical collisions, but you are still the ceiling. Your review bandwidth determines how many agents you can actually run, not the tool.Codex 内置了 Git worktree 支持因此多个任务可以同时处理同一个代码仓库而不会互相冲突。Claude Code 通过git worktree提供同样的隔离能力可以使用--worktree标志在独立工作副本中打开会话也可以给 Sub-agent 设置isolation: worktree让每个辅助 Agent 获得一个全新的工作副本并在任务结束后自动清理。我在《The Orchestration Tax编排税》中讨论过这件事对人的影响Git worktree 消除了机械层面的冲突但你仍然是整个系统的上限。真正决定你能同时运行多少个 Agent 的是你的审查带宽而不是工具本身。Skills: so you stop explaining your project every timeSkills不必每次都重新解释项目A skill is how you stop re-explaining the same project context every session like a goldfish. Both tools use the same format: a folder containing aSKILL.mdwith instructions and metadata, plus optional scripts, references, and assets. Codex runs a skill when you call it with$or/skills, or automatically when your task matches the skill description. That is why a tight, straightforward description beats a clever one. Claude Code works the same way, and I wrote up the pattern in agent skills.Skill 可以让你不必像金鱼一样在每次会话中反复解释相同的项目上下文。两款工具采用相同格式一个包含SKILL.md的文件夹文件中保存说明和元数据另外还可以包含可选的脚本、参考资料和资源。当你通过$或/skills调用 Skill 时Codex 会运行它当任务与 Skill 描述匹配时Codex 也可以自动调用它。这就是为什么紧凑、直接的描述往往比花哨的描述更有效。Claude Code 的工作方式也一样我在《Agent Skills》中介绍过这种模式。Skills are also where intent stops costing you over and over. In intent debt, I argued that an agent starts every session cold and fills any gap in your intent with a confident guess. A skill is that intent written down externally: the conventions, build steps, and the “we do not do it this way because of that one incident” rules, written once where the agent can read them on every run. Without skills, the loop re-derives your whole project from zero every cycle. With skills, the knowledge compounds.Skills 还能让你不必反复为表达意图付出成本。我在《Intent Debt意图债务》中提出Agent 每次启动会话时都处于冷启动状态它会用自信的猜测填补你意图中的任何空白。Skill 就是把意图写在外部项目约定、构建步骤以及“因为发生过那次事故所以我们不这样做”等规则只需写一次Agent 就能在每次运行中读取。没有 Skills循环每一轮都要从零开始重新推导整个项目有了 Skills项目知识便会不断积累。One thing to keep straight: the skill is the authoring format, and a plugin is how you ship it. When you want to share a skill across repos or bundle several together, you package them as a plugin. That is true in Codex and true in Claude Code.有一点需要明确Skill 是内容的编写格式而 Plugin 是发布 Skill 的方式。如果你想在多个代码仓库之间共享 Skill或者把多个 Skills 打包在一起就可以把它们封装成 Plugin。Codex 如此Claude Code 也如此。Plugins and connectors: the loop touches your real toolsPlugins 与 Connectors让循环接触真实工具A loop that can only see the filesystem is a very small loop. Connectors, built on MCP, let the agent read your issue tracker, query a database, hit a staging API, or drop a message in Slack. Codex and Claude Code both speak MCP, so a connector you write for one will usually work in the other. Plugins bundle connectors and skills together so a teammate can install your setup in one go instead of rebuilding it from memory.一个只能访问文件系统的循环能力会非常有限。基于 MCP 构建的 Connectors可以让 Agent 读取 issue tracker、查询数据库、访问 staging API或者在 Slack 中发送消息。Codex 和 Claude Code 都支持 MCP因此你为其中一个工具编写的 Connector通常也能在另一个工具中直接使用。Plugins 可以把 Connectors 和 Skills 打包在一起让团队成员一次性安装整套配置而不必凭记忆重新搭建。This is the difference between an agent that says “here is the fix” and a loop that opens the PR, links the Linear ticket, and pings the channel once CI is green by itself. Connectors are why the loop can act inside your actual environment instead of merely telling you what it would do if it could.这就是“Agent 告诉你‘修复方案在这里’”与“循环自动创建 PR、关联 Linear 工单并在 CI 变绿后主动通知频道”之间的区别。正是 Connectors 让循环能够在你的真实环境中采取行动而不只是告诉你如果它有能力执行它会怎么做。Sub-agents: keep the maker away from the checkerSub-agents将实现者与检查者分开The most useful structural feature in a loop, by far, is separating the person who writes from the person who checks. The model that wrote the code is far too generous when grading its own homework. A second agent with different instructions—and sometimes a different model—catches the things the first agent talked itself into accepting.循环中最有用的结构设计无疑是把负责实现的人与负责检查的人分开。编写代码的模型在给自己的作业打分时往往过于宽容。另一个拥有不同指令、甚至使用不同模型的 Agent可以发现第一个 Agent 自我说服后接受的问题。Codex only spawns sub-agents when you ask. It runs them at the same time and then folds the results back into one answer. You define your own agents as TOML files in.codex/agents/, each with a name, description, instructions, and optional model and reasoning effort. Your security reviewer can therefore be a strong model with high effort, while your explorer can be a fast, read-only model. Claude Code does the same with subagents in.claude/agents/and with agent teams that pass work between them. The usual split in both tools is: one agent explores, one implements, and one verifies against the specification.Codex 只会在你提出要求时创建 Sub-agents。它们可以同时运行最后再把结果汇总成一个答案。你可以在.codex/agents/中用 TOML 文件定义自己的 Agents每个 Agent 都包含名称、描述、指令以及可选的模型和推理强度。这样安全审查 Agent 可以使用高推理强度的强模型而探索 Agent 则可以使用快速、只读的模型。Claude Code 也通过.claude/agents/中的 Sub-agents以及能够相互传递工作的 Agent Teams实现同样的效果。两款工具中常见的分工是一个 Agent 负责探索一个 Agent 负责实现另一个 Agent 根据规范进行验证。I have made this case twice already, once in the code agent orchestra and once in adversarial code review. It matters specifically inside a loop because the loop runs while you are not watching. A verifier you actually trust is the reason you can walk away. Subagents do burn more tokens, since each one performs its own model and tool work, so spend them where a second opinion is worth paying for. This is also basically what Claude Code’s/goaldoes under the hood: a fresh model decides whether the loop is done instead of the model that did the work. The maker-checker split is applied to the stopping condition itself.我已经两次阐述过这个观点一次是在《The Code Agent Orchestra代码 Agent 乐团》中另一次是在《Adversarial Code Review对抗式代码审查》中。它在循环中尤其重要因为循环会在你没有关注时继续运行只有真正值得信任、负责验证的 Agent才能让你放心离开。Sub-agent 确实会消耗更多 Token因为每个 Sub-agent 都要独立完成模型推理和工具调用所以只应在值得为独立复核付出额外成本的地方使用它们。Claude Code 的/goal在底层基本也是这样工作的由一个全新的模型判断循环是否完成而不是由执行任务的模型自己判断。也就是说实现者与检查者的分离同样被应用到了停止条件上。What one loop looks like一个循环的实际形态Put it all together, and a single thread turns into a small control panel. Here is one pattern I keep using.把这些部分组合起来一个任务就会变成一个小型控制面板。下面是我经常使用的一种模式。An automation runs every morning on the repo. Its prompt calls a triage skill that reads yesterday’s CI failures, open issues, and recent commits, then writes the findings into a Markdown file or a Linear board. For each finding worth acting on, the thread opens an isolated worktree and sends a sub-agent to draft the fix. A second sub-agent reviews that draft against the project skills and the existing tests.每天早上一个 Automation 会在代码仓库上运行。它的 Prompt 调用一个分类处理 Skill读取昨天的 CI 失败、未关闭的问题和近期提交然后把发现结果写入 Markdown 文件或 Linear 看板。对于每一项值得处理的发现任务都会创建一个隔离的 Git worktree并派出一个 Sub-agent 起草修复方案第二个 Sub-agent 则根据项目 Skills 和现有测试审查这份草案。Connectors let the loop open the PR and update the ticket. Anything the loop cannot handle lands in my Triage inbox. The state file is the spine of the whole thing: it remembers what was tried, what passed, and what is still open, so tomorrow morning’s run picks up where today’s run stopped.Connectors 让循环能够创建 PR 并更新工单。循环无法处理的内容都会进入我的 Triage 收件箱。状态文件是整个系统的主干它记录尝试过什么、什么已经通过以及什么仍未解决因此第二天早上的运行可以从当天停止的位置继续。Look at what you actually did there. You designed it once. You did not prompt any of those steps. That is Steinberger’s whole point made real, and it is the same loop in Codex or Claude Code because the pieces are the same pieces.再看看你实际上做了什么你只设计了一次却没有亲自为其中任何步骤编写 Prompt。这就是 Steinberger 观点的具体体现。而且无论在 Codex 还是 Claude Code 中这都是同一种循环因为它们使用的是同一组基础组件。What the loop still does not do for you循环仍然不会替你完成的事情The loop changes the work; it does not remove you from it. And three problems actually become sharper as the loop gets better, not easier.循环会改变工作方式但并不意味着你可以置身事外。而且循环越完善下面三个问题反而会变得更尖锐而不是更容易解决。Verification is still on you. A loop running unattended is also a loop making mistakes unattended. The whole reason you split the verifier sub-agent from the maker is to make the loop’s “it’s done” mean something. Even then, “done” is a claim, not proof. I keep repeating the same line from code review in the age of AI: your job is to ship code you have confirmed works.验证仍然是你的责任。无人值守运行的循环也会在无人监督的情况下犯错。把验证型 Sub-agent 与实现者分开的根本原因是为了让循环所说的“已经完成”具有实际意义。即便如此“完成”仍然只是一项声明而不是证明。我在《Code Review in the Age of AIAI 时代的代码审查》中反复强调同一句话你的职责是交付那些已经由你确认能够正常运行的代码。Your understanding still rots if you allow it. The faster the loop ships code you did not write, the bigger the gap between what exists and what you actually understand. That is comprehension debt, and a smooth loop only makes it grow faster unless you read what the loop made.如果你放任不管你对系统的理解仍会逐渐退化。循环越快地交付那些不是你亲手编写的代码现实中存在的内容与你真正理解的内容之间差距就会越大。这就是 comprehension debt理解债务。除非你认真阅读循环生成的内容否则一个运行顺畅的循环只会让这种债务增长得更快。And the comfortable posture is the dangerous one. When the loop runs itself, it is very tempting to stop having an opinion and simply accept whatever it gives back. I called that cognitive surrender. Designing the loop is the cure when you do it with judgment, and the accelerant when you do it to avoid thinking—the same action, with the opposite result.而最舒适的状态恰恰也是最危险的。当循环能够自行运行时你很容易停止独立判断只是照单全收它返回的结果。我把这种状态称为 cognitive surrender认知投降。如果你带着判断力设计循环它就是解药如果你设计循环只是为了逃避思考它就会成为加速器。同一个行动结果却完全相反。Build the loop. Stay the engineer.构建循环始终做工程师I think this is a preview of how our work is going to evolve. That said, if I were not reviewing the code myself, or if I relied entirely on automated loops to fix it, my product’s quality would suffer. I would likely end up stuck in a downward spiral, continuously digging myself into a deeper hole.我认为这预示着我们的工作方式将如何演变。话虽如此如果我不亲自审查代码或者完全依赖自动化循环修复代码产品质量就会受到影响。我很可能会陷入恶性循环不断把自己挖进更深的坑里。That said, go ahead and set up your loops, but do not forget that prompting your agents directly is also effective. It is all about finding the right balance.话虽如此你尽管去搭建自己的循环但不要忘记直接给 Agent 编写 Prompt 同样有效。关键在于找到合适的平衡。Loops can also produce different outcomes depending on who is using them. Two people can build the exact same loop and get completely opposite results. One uses it to move faster on work they understand deeply. The other uses it to avoid understanding the work at all. The loop does not know the difference. You do.循环还会因为使用者不同而产生不同结果。两个人可以构建完全相同的循环却得到截然相反的结果。一个人用它加快自己已经深入理解的工作另一个人却用它来彻底逃避理解这项工作。循环不知道其中的区别但你知道。That is what makes loop design harder than prompt engineering, not easier. Cherny’s point is not that the work became easier. It is that the leverage point moved.这正是循环设计比 Prompt Engineering提示工程更难、而不是更容易的原因。Cherny 的观点并不是工作变简单了而是杠杆点发生了转移。Build the loop. But build it like someone who intends to stay the engineer—not merely the person who presses go.构建循环。但要像一个打算始终做工程师的人那样构建它而不要只做那个按下启动按钮的人。