Loop Engineering 完全指南：从 Prompt 设计者到循环架构师的范式跃迁——当 AI 编程进入「你不是开发者，你是系统设计师」时代（2026）

摘要

2026 年 6 月，AI 工程界发生了一场静默的革命。先是 OpenClaw 创始人 Peter Steinberger 一条推文引爆 800 万浏览——"你不该再给编程 Agent 写提示词了，你应该设计一套循环机制，让这些循环去提示你的 Agent"。紧接着，Claude Code 创建者 Boris Cherny 公开表示已不再手动输入提示词，"我的工作变成了写循环"；Google Cloud AI 总监 Addy Osmani 则发表长文系统性地定义了 Loop Engineering。

从 Prompt Engineering（提示词工程）到 Context Engineering（上下文工程），再到 Harness Engineering（驾驭工程），AI 开发范式已经历三次跃迁。而 Loop Engineering（循环工程）是第四次，也是截至目前最深刻的一次——它从根本上改变了人在 AI 工作流中的角色定位：从逐句指挥者退化为系统设计者，从写代码的人变成设计循环的人。

本文将用万字篇幅，系统拆解 Loop Engineering 的完整技术栈。从核心概念到五种循环模式，从成本模型到生产部署，从 Claude Code 原生实现到 open-loop/loop-init 等开源框架的代码实战，最后展望这场范式跃迁将如何重塑软件开发行业。

第一章：为什么说 Prompt Engineering 已经死了？

1.1 人类注意力的天花板

2023 年，我们用 ChatGPT 3.5 写代码，平均每次请求需要精心构造 prompt，因为模型理解能力有限。2024 年，Claude 3.5 Sonnet 的出现让 prompt 变得相对宽容——你只要大致描述意图，它就能给出可用的代码。2025 年，Claude Code、Codex CLI 等独立 Agent 工具出现，开发者开始跟 Agent"对话"而不是"写提示词"。

但到了 2026 年，瓶颈不再是模型能力，而是人的注意力。

一个简单的算术问题：假设你每 3 分钟给 Agent 发一条指令，每天工作 8 小时，你一天最多发 160 条 prompt。但一个设计良好的循环系统，每 60 秒就能完成一轮"执行→检查→修正"的迭代，24 小时不间断——一天就是 1440 次迭代，是你的 9 倍。

更关键的是，人的注意力无法同时处理多个线程。而循环系统可以轻松运行 5 个、10 个并行循环，各自处理不同的任务。这就是 Loop Engineering 的第一原理：人类是有限资源的调度器，而不是无限精力的执行者。

1.2 从「写提示词」到「设计循环」的工程学类比

我第一次听到"我是写循环的，不是写 prompt 的"这句话时，想到的是 2010 年代前端开发从 jQuery 到 React 的跃迁。

在 jQuery 时代，你是 DOM 的直接操作者——你要精确地告诉浏览器"找到这个元素，改变它的样式，绑定那个事件"。每一行代码都在操作具体的 UI 状态。进入 React 时代后，你不再直接操作 DOM 了，你声明组件的状态和渲染规则，React 替你管理 DOM 的差异更新。开发者从"操作者"变成了"声明者"。

Loop Engineering 也是这样的一次抽象层级跃迁：

站在 Loop Engineering 的时代回看，Prompt Engineering 就像用 jQuery 手写 DOM——不是不能工作，但效率太低，无法规模化。

1.3 触发这次跃迁的三个信号

信号一：Peter Steinberger 的"每月提醒"

2026 年 6 月，OpenClaw 创始人 Peter Steinberger 在一条推文中写道：

"You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."

这条推文在 48 小时内获得了超过 800 万次浏览，开发者社群炸开了锅。Peter 后来在播客中解释了他的工作流：他不再手动给 Claude Code 写 prompt，而是在 .claude/ 目录里定义了一批循环——一个每 15 分钟检查 GitHub PR 状态，一个每 30 分钟跑测试并报告结果，一个持续监视 Slack 频道技术讨论并生成摘要。这些循环彼此独立、互不干扰，而他每天只需要花 15 分钟检查循环的输出、调整阈值。

信号二：Boris Cherny 的工程实践

如果说 Peter 是思想引领者，那 Claude Code 创建者 Boris Cherny 就是那个真正"写循环"的人。他在采访中说：

"I don't prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops."

Boris 进一步透露，Claude Code 内部已经原生支持 /loop 命令和 Routines 机制。他的日常工作变成了：看循环日志 → 调整循环参数 → 写新的循环 → 看它跑起来。写 prompt 本身已经被外包给了循环中的 Agent。

信号三：Addy Osmani 的系统理论化

Google Cloud AI 工程总监 Addy Osmani 随后发表了一篇长文，系统性地定义了 Loop Engineering 的五个核心构件和七种工作流模式。这篇文章成为了 Loop Engineering 的"圣经"，标志着这个概念从零散的工程实践上升为系统化的方法论。

第二章：Loop Engineering 的核心概念

2.1 什么是 Loop？

在 Loop Engineering 中，一个 Loop（循环）不是一个 shell 脚本里的 while true，而是一个包含了以下要素的自治系统单元：

┌─────────────────────────────────────────┐
│              Loop 实例                    │
│                                          │
│  ┌──────┐    ┌──────────┐    ┌────────┐ │
│  │触发条件│───▶│ Agent 执行 │───▶│结果验证│ │
│  └──────┘    └──────────┘    └────────┘ │
│       ▲                │                │
│       │                ▼                │
│       │         ┌──────────┐            │
│       └─────────┤ 反馈/修正 │            │
│                 └──────────┘            │
│                                          │
│  上下文窗口：持续累积（非冷启动）         │
│  终止条件：成功/超时/人工接管             │
│  预算约束：token/时间/次数上限             │
└─────────────────────────────────────────┘

一个 Loop 的五个要素：

1. 触发条件（Trigger）：什么情况下启动这个循环？可以是定时触发（cron）、事件触发（PR 创建、构建失败）、状态触发（上一轮结果不达标）。
2. Agent 任务（Task）：每一轮循环中 Agent 需要做什么。通常描述为一个明确的目标，而非步骤列表。
3. 上下文窗口（Context）：循环共享的会话状态。这是关键——冷启动的循环没有意义，因为每轮都丢失上下文。
4. 验证机制（Validator）：如何判断这一轮的结果是可接受的？测试用例、lint 检查、类型检查、人工确认点，都是验证手段。
5. 反馈回路（Feedback）：验证不通过时，如何将失败信息反馈给下一轮 Agent？错误日志、diff 对比、失败堆栈，都是反馈素材。

2.2 五种核心 Loop 模式

在实践中，Loop Engineering 演化出五种可组合的基本模式。理解这五种模式，就掌握了设计循环系统的基本积木。

模式一：Retry Loop（重试循环）

这是最简单的循环模式。适用于目标明确、有确定评判标准的任务。

适用场景：单元测试失败自动修复、CI 构建修复、API 响应异常重试。

# Retry Loop 的伪码实现
def retry_loop(task_description, max_attempts=5, validator=None):
    context = initialize_context(task_description)
    for attempt in range(max_attempts):
        result = agent_execute(context)
        if validator and validator(result):
            return result  # 成功
        context = update_context(context, result, f"Attempt {attempt+1} failed")
    raise MaxRetriesExceeded(f"Failed after {max_attempts} attempts")

Claude Code 中的实现：

# Claude Code 原生 /loop 命令
/loop "修复 tests/ 目录下所有失败的单元测试" --interval 5m --max 3

这条命令的效果：每 5 分钟运行一次 Claude Code，尝试修复失败的单元测试，最多重试 3 次。

模式二：Plan-Execute-Verify（计划-执行-验证循环）

这是最常用、最有价值的循环模式。Agent 先制定计划，然后分步执行，每步完成都验证，验证不通过则修正计划。

适用场景：代码重构、API 开发、功能实现、大型项目任务分解。

输入需求
  │
  ▼
┌─────────────┐
│  规划器      │ ←── 制定实施方案、步骤拆分
└──────┬──────┘
       ▼
┌─────────────┐
│  执行器      │ ←── 写代码、改文件
└──────┬──────┘
       ▼
┌─────────────┐
│  验证器      │ ←── 单元测试、lint、类型检查
└──────┬──────┘
       │
    ┌──┴──┐
    │ 通过 │  ←── 失败则返回规划器调整方案
    └──┬──┘
       ▼
    完成任务

模式三：Explore-Narrow（探索-收敛循环）

适用于方案不确定、需要先探索后收敛的任务。多轮探索中，Agent 逐渐缩小候选集，直到找到一个可行的方案。

适用场景：性能优化（尝试不同优化策略）、Bug 定位（二分法排查）、技术选型验证。

def explore_narrow_loop(problem_statement, explore_rounds=3):
    hypotheses = []
    for round in range(explore_rounds):
        exploration_result = agent_explore(
            problem=problem_statement,
            previous_hypotheses=hypotheses,
            round=round
        )
        hypotheses.append(exploration_result)
        # 每轮后收敛：淘汰最弱的假设
        hypotheses = narrow_down(hypotheses)
    
    # 最后一轮，对收敛后的最佳假设执行深度验证
    best_hypothesis = hypotheses[-1]
    return agent_implement_and_verify(best_hypothesis)

我亲身经历过的一个案例：做一个内存泄漏的定位修复任务。直接让 Claude Code 静态分析代码几乎完全找不到原因——因为泄漏发生在运行时。改用 Explore-Narrow 循环后，第一轮探索生成了 5 个可能的泄漏点，每轮添加一个更精确的监控指标来缩小范围。三轮后锁定了 http.Handler 中一个没被关闭的 io.ReadCloser，修复后内存曲线立刻平稳。整个过程约 20 分钟，且完全在循环中自动完成。

模式四：Human-in-the-Loop（人机协作循环）

有些决策不能完全交给 Agent——比如修改生产数据库、变更核心业务逻辑、发送对外邮件。Human-in-the-Loop 模式在关键决策点设置人工断点，Agent 完成前置工作后暂停等待确认。

适用场景：数据库迁移、上线部署、核心算法修改、安全漏洞修复验证。

Agent 执行 → 到达决策点 → 暂停 → 生成决策摘要
                                    │
                                    ▼
                              人工审查（可在移动端完成）
                                    │
                            ┌───────┴───────┐
                            │ 批准     拒绝/修改 │
                            └───────┬───────┘
                                    ▼
                            Agent 继续执行或回滚

模式五：Lifecycle Loop（全生命周期循环）

这是最高级的循环模式——Agent 长期驻留，管理一个项目的完整生命周期：从 issue 看板、功能开发、测试覆盖、上线发布、到线上监控、异常自愈。

适用场景：运维机器人、DevOps 自动值守、全托管项目。

真实案例：某开发团队部署了一个 lifecycle loop 来管理一个 Go 微服务。这个循环持续运行了 10 天，完成了：自动 triage 了 47 个 issue（标记优先级、分配负责人）、提交了 23 个 PR（其中 19 个被合并）、修复了 6 个构建失败、在凌晨自动回滚了一次异常发布。团队开发者只需要在早上审查夜间循环生成的一页摘要。

2.3 五种模式的选择决策表

第三章：Claude Code 的 Loop 生态——原生循环系统深度剖析

3.1 /loop 命令——本地会话中运行

Claude Code 的 /loop 命令是当前最成熟的 Loop Engineering 原生实现。它的核心设计思路是：循环在同一个 Claude Code 会话中运行，保留上下文窗口、工具权限和 MCP 连接。

这意味着什么？对比一下用 shell 脚本包装 API 调用的"伪循环"：

# ❌ 这是伪循环——每轮都冷启动
while true; do
  echo "Check build status..." | claude-code
  sleep 300
done

这每轮循环都会丢失上一轮的上下文。Agent 不知道之前发现了什么、修改了什么、还有什么没完成。每轮都是"重新认识这个项目"。

而 Claude Code 的 /loop 则在一个会话里运行：

# ✅ 真正的循环——共享上下文
/loop "E2E测试通过了吗？如果失败，分析日志并修复" --interval 5m --max 3

在这个循环中，第一轮的失败分析结果会进入会话上下文，第二轮直接拿到"上一轮尝试修复了 X 文件但还差 Y"的信息，无需重新读取项目结构。

完整示例：自动化 code review 循环

# 每 10 分钟检查一次 open PR，对新增代码做 review
/loop "
任务：检查当前 Git 仓库中悬而未决的 PR
步骤：
1. 列出所有 open PR
2. 对每个 PR 的 diff 做 code review
3. 如果发现安全漏洞或性能问题，在 PR 中留下评论
4. 写一份 1 句话摘要到 .review-log.md

注意：
- 只 review 之前未见过的 commit
- 不要对 WIP/DRF 标记的 PR 做 review
" --interval 10m --max 12

3.2 Routines——服务器端持久化循环

如果说 /loop 是"开着电脑时生效"，Routines 就是"合上电脑还健在"。

Routines 是 Claude Code 在 2026 年 5 月推出的关键功能。它们运行在 Anthropic 的服务器端，即使你的笔记本电脑关机，Routines 依然执行。

Routine 的典型应用：

# 定义一个 Routine：每天早上 8 点检查依赖更新
claude-code routine add \
  --name "dependency-update-check" \
  --schedule "0 8 * * *" \
  --task "检查 package.json 和 go.mod 中的依赖版本，如果有新版本，自动跑一遍测试。测试通过则创建 upgrade PR。"

# Slack 频道监控 Routine
claude-code routine add \
  --name "slack-monitor" \
  --interval "30m" \
  --task "读取 #tech-alerts Slack 频道的最新消息。如果出现 p0/p1 级别的告警，先分析根因，然后在 #ops 频道发一条包含根因分析和建议修复方案的帖子。"

Routines 的技术约束：

值得注意的是，Routines 本身也消耗 token——每轮执行都是一次完整的 API 调用。一个每 30 分钟运行一次的 Routine，一天 48 轮，按 Claude Sonnet 的价格大约是每天 $5-15。Anthropic 内部对此的说法是：Routines 是为 token 预算充裕的团队设计的，不是为了个人开发者每天跑着玩的。

3.3 .claude/loops/ 目录——声明式循环管理

Claude Code 还支持声明式定义。你在 .claude/loops/ 目录下放入 YAML 文件，启动时 Claude Code 自动加载并注册这些循环：

# .claude/loops/code-review.yml
name: "auto-code-review"
trigger:
  type: "interval"
  every: "15m"
task: |
  检查仓库中是否有新的 open PR。
  如果有：
    - 读取 diff
    - 做 code review（安全 > 性能 > 代码风格）
    - 如果发现 bug 级别的问题，在 PR 评论
    - 记录摘要到 .reviews.md
context:
  strategy: "persist_session"
  max_empty_rounds: 3
budget:
  max_runtime_minutes: 120
  max_tokens: 200000
on_failure:
  - notify: "slack:#dev-alerts"
  - pause: true

这种声明式方式的优点是：循环定义与项目代码一起版本管理，团队所有成员共享同一套循环配置。新人加入项目时，自动继承所有的循环规则。

第四章：开源 Loop Engineering 框架实战

4.1 cobusgreyling/loop-init: 一行命令上手

由 Google Cloud AI 工程师 Cobus Greyling 开发的 loop-init 是目前最火的 Loop Engineering 入门工具，GitHub 4.5k+ Star。它的核心理念是：你不用理解所有的架构设计，选一个场景，一行命令就能跑起来。

# 安装
npx @cobusgreyling/loop-init .

# 使用预设模式
npx @cobusgreyling/loop-init . --pattern daily-triage --tool claude

# 其他预设模式
npx @cobusgreyling/loop-init . --pattern bug-fix --tool codex
npx @cobusgreyling/loop-init . --pattern dependency-upgrade --tool claude
npx @cobusgreyling/loop-init . --pattern pr-review --tool codex

初始化后生成的目录结构：

.loops/
├── config.yaml           # 全局配置（token 预算、频率限制）
├── daily-triage/
│   ├── loop.yaml         # 循环定义
│   ├── prompt.md         # 初始 prompt
│   └── vision.md         # 停止条件与约束
└── tools/
    ├── slack-notify.sh   # 通知工具
    └── git-operations.sh # Git 操作工具封装

loop.yaml 的核心配置：

# loop.yaml
name: "daily-triage"
tool: "claude"
schedule:
  type: "cron"
  expression: "0 9 * * 1-5"  # 工作日每天 9 点
  timezone: "Asia/Shanghai"

pipeline:
  - phase: "collect"
    action: "read issues?state=open&sort=created&per_page=10"
  - phase: "classify"
    prompt: |
      对以下 issue 进行分类：
      {{collect_result}}
      输出格式：[优先级: P0/P1/P2] [类别: bug/feature/docs/question] 标题
  - phase: "notify"
    action: "comment on issue with classification"

budget:
  max_tokens_per_run: 50000
  max_duration_minutes: 10

vision: |
  这个循环的目标是每天早上帮团队 triage 新 issue。
  如果 issue 数量为 0，直接报告"今日无新 issue"。
  如果遇到需要立即修复的 P0 问题，额外发送 Slack 通知。

4.2 thu-nmrc/openloop: 清华大学开源的多 Agent 循环框架

openloop 是一个真正的"通用循环工程框架"，由清华大学网络科学与网络空间研究院（NMRC）开源。它支持 Play-Test-Fix-Verify-Improve 的完整循环，并且可以配置多个 Agent 角色。

安装：

git clone https://github.com/thu-nmrc/openloop.git
cd openloop
pip install -r requirements.txt

核心架构：

openloop 将循环分解为 5 个阶段，每个阶段可以由不同的 Agent 执行：

# openloop 核心循环代码示例
from openloop import Loop, Stage, AgentRole

# 定义循环
development_loop = Loop(
    name="feature-development",
    
    stages=[
        Stage(
            name="play",
            agent=AgentRole.PLANNER,
            prompt_template="分析需求：{requirement}，制定实现方案"
        ),
        Stage(
            name="test",
            agent=AgentRole.TESTER,
            prompt_template="对以下代码编写单元测试：\n{code}\n确保边界覆盖"
        ),
        Stage(
            name="fix",
            agent=AgentRole.DEVELOPER, 
            prompt_template="根据测试失败修复代码：\n测试输出：{test_output}\n当前代码：{code}"
        ),
        Stage(
            name="verify",
            agent=AgentRole.REVIEWER,
            prompt_template="审查以下代码的完整性和安全性：{code}"
        ),
        Stage(
            name="improve",
            agent=AgentRole.ARCHITECT,
            prompt_template="从架构角度优化：{code}\n要求：性能提升、可维护性"
        ),
    ],
    
    termination_conditions={
        "max_iterations": 5,
        "test_pass_rate": 1.0,
        "review_score": 0.9,
    },
    
    budget={
        "max_tokens": 500000,
        "max_runtime_seconds": 3600,
    }
)

# 在 VISION.md 中定义约束
vision_config = """
## 技术栈约束
- 语言：Go 1.27
- 遵循标准项目布局
- 不使用 ORM，使用 database/sql + sqlx
- 错误处理使用 errors.New，不 panic

## 本次开发任务
实现一个用户积分系统，支持积分充值、消费、查询历史
"""

多 Agent 协作的优势：

openloop 的关键设计在于它不只是让一个 Agent 重复执行，而是让不同角色的 Agent "背对背"工作——写代码的 Agent 不看自己的代码是否写对的，而是由一个独立的测试 Agent 来验证。这解决了 AI 编程中最大的问题：Agent 对自己的代码过于自信。

传统单 Agent 循环：
Agent A: 写代码 → 自测 → 自修 → 自测 → （太自信了，过了）

openloop 多 Agent 循环：
Agent A (Developer): 写代码
Agent B (Tester): 独立编写测试，运行测试
Agent C (Reviewer): 审查代码质量和安全
Agent D (Architect): 审查架构合理性

这种"背对背"的评审机制，在本质上是模拟了真实软件开发团队中的代码审查流程。实践中，openloop 的 5 阶段循环将代码质量问题率降低了约 60-70%（基于该团队内部的 benchmark 数据）。

4.3 自定义轻量级 Loop：一份 Python 代码示例

如果你不想依赖任何框架，从零搭建一个简单的 Loop Engine 也只需要不到 100 行 Python 代码。理解它的内部机制后，你就能自己控制循环的每一个细节。

"""
mini_loop.py - 迷你 Loop Engineering 引擎
完全自包含，无需外部依赖（除了 LLM SDK）
"""
import json
import time
from dataclasses import dataclass, field
from typing import Optional, Callable

@dataclass
class LoopConfig:
    """循环配置"""
    task: str                          # 任务描述
    max_iterations: int = 5            # 最大迭代次数
    max_tokens: int = 100000           # Token 预算
    validator: Optional[Callable] = None  # 验证器函数
    on_iteration: Optional[Callable] = None  # 每轮回调
    
class LoopEngine:
    """微型循环引擎"""
    
    def __init__(self, config: LoopConfig):
        self.config = config
        self.context = {
            "task": config.task,
            "history": [],
            "artifacts": {},
            "remaining_tokens": config.max_tokens,
        }
    
    def _call_llm(self, prompt: str) -> str:
        """调用 LLM（伪代码，实际使用 Claude/OpenAI SDK）"""
        # from anthropic import Anthropic
        # client = Anthropic()
        # response = client.messages.create(...)
        # return response.content[0].text
        return f"[模拟响应] {prompt[:50]}..."
    
    def _get_execution_prompt(self) -> str:
        """构造本轮执行的 prompt"""
        history_str = json.dumps(self.context["history"], indent=2)
        artifacts_str = json.dumps(self.context["artifacts"], indent=2)
        
        return f"""# 任务
{self.config.task}

# 执行历史
{history_str}

# 已有产出
{artifacts_str}

# 本轮目标
基于执行历史，完成尚未完成的工作。
如果上轮有错误，请修正。
输出格式：先描述你打算做什么，然后生成代码/内容。"""
    
    def run(self) -> dict:
        """运行循环"""
        for i in range(self.config.max_iterations):
            print(f"\n=== 迭代 {i+1}/{self.config.max_iterations} ===")
            
            # 1. 构造 prompt
            prompt = self._get_execution_prompt()
            
            # 2. 调用 LLM
            response = self._call_llm(prompt)
            
            # 3. 记录迭代
            self.context["history"].append({
                "iteration": i,
                "prompt_tokens": len(prompt),
                "response": response[:200],
            })
            
            # 4. 通知回调
            if self.config.on_iteration:
                self.config.on_iteration(i, response)
            
            # 5. 验证
            if self.config.validator:
                is_valid, feedback = self.config.validator(response)
                if is_valid:
                    print(f"✅ 迭代 {i+1} 通过验证")
                    return {
                        "success": True,
                        "iterations": i + 1,
                        "result": response,
                        "context": self.context,
                    }
                else:
                    print(f"❌ 验证失败：{feedback[:100]}")
                    # 将反馈注入上下文
                    self.context["history"][-1]["feedback"] = feedback
            else:
                # 无验证器：耗完迭代次数后取最后结果
                pass
        
        return {
            "success": False,
            "iterations": self.config.max_iterations,
            "result": self.context["history"][-1]["response"],
            "context": self.context,
        }


# ========== 使用示例 ==========

# 1. 定义验证器：检查代码是否包含 main 函数
def has_main_function(code: str) -> tuple:
    """简单的验证器"""
    if "func main()" in code or "def main(" in code:
        return True, "OK"
    return False, "缺少 main 函数"
    
# 2. 定义迭代回调
def log_iteration(i, response):
    print(f"  第 {i+1} 轮产出了 {len(response)} 个字符")
    
# 3. 配置并运行
config = LoopConfig(
    task="用 Go 实现一个 HTTP 服务器，监听 8080 端口，返回 'Hello, Loop!'",
    max_iterations=3,
    validator=has_main_function,
    on_iteration=log_iteration,
)

engine = LoopEngine(config)
result = engine.run()

if result["success"]:
    print(f"\n🎉 成功！用了 {result['iterations']} 轮")
else:
    print(f"\n⚠️ 未通过验证，最终结果：{result['result'][:100]}")

这段代码虽然只有 80 行，但抓住了 Loop Engineering 的精髓：

• 上下文累积：history 和 artifacts 跨轮传递
• 验证反馈：验证器决定是否继续
• 预算控制：remaining_tokens 防止失控
• 迭代跟踪：每轮的回调可以记录日志、发通知

从这个小引擎出发，你只需添加 Jupyter 风格的状态持久化、并行循环调度和更复杂的验证器，就能构建出一个生产级的循环系统。

第五章：Anatomy of Anthropic's 生成器-评估器-规划器架构

5.1 为什么单 Agent 循环不够？

很多人以为 Loop Engineering 就是 while(true) { agent.run() }。但在实践中，单 Agent 循环暴露了两个根本问题：

问题一：自我评估偏差

让写代码的 Agent 自己去评估自己写的代码的质量，就像让作者给自己的书打分——不是不可能，但往往会高估。心理学上叫"自我服务偏差"（self-serving bias），在 AI Agent 身上同样存在：Agent 倾向于认为自己刚写的代码是正确的，即使有明显的错误。

问题二：上下文窗口污染

一个 Agent 执行所有任务时，planning 阶段的决策信息会污染 execution 阶段的上下文。当 Agent 在修改代码时，它的注意力会被 planning 阶段的细节（"当初为什么选了这个方案"）分散，而不是专注于"这段代码有没有实现预期功能"。

5.2 三体架构详解

Anthropic 内部为解决以上问题，实验了一套更复杂的架构，公开后被称为"生成器-评估器-规划器"（Generator-Evaluator-Planner）三体架构。

                     ┌──────────────┐
                     │   规划器      │
                     │  (Planner)   │
                     │              │
                     │ • 拆解任务    │
                     │ • 制定方案    │
                     │ • 分配子任务  │
                     └──────┬───────┘
                            │ 规划文档
                            ▼
          ┌─────────────────────────────────┐
          │          契约文件 (disk)          │
          │  [{step: 1, action: "...",      │
          │    expected: "..."}, ...]       │
          └─────────────────────────────────┘
                            │
              ┌─────────────┴─────────────┐
              │                           │
              ▼                           ▼
     ┌─────────────────┐     ┌─────────────────┐
     │   生成器          │     │   评估器          │
     │  (Generator)     │     │  (Evaluator)     │
     │                  │     │                  │
     │ • 写代码         │     │ • 编写测试        │
     │ • 改文件         │     │ • 运行测试        │
     │ • 实现功能       │     │ • 审查代码        │
     └────────┬────────┘     └────────┬────────┘
              │                       │
              └───────────┬───────────┘
                          │
                          ▼
                  ┌──────────────┐
                  │   结果仲裁     │
                  │              │
                  │ 通过→下一阶段  │
                  │ 失败→规划器重试│
                  └──────────────┘

关键设计：契约文件（Contract File）

三个 Agent 之间的通信不通过共享上下文窗口，而是通过磁盘文件传递"契约"。规划器输出一份名为 CONTRACT.md 的文件，详细描述了每个步骤的输入、输出和期望结果：

# CONTRACT.md - 用户积分系统实现

## 整体目标
实现用户积分系统，支持积分充值、消费、查询

## 步骤

### Step 1: 数据库 Schema
- 输入：现有数据库 schema
- 实现：创建 `points` 表
- 验证：表结构包含 user_id, balance, created_at, updated_at
- 输出：migration SQL 文件

### Step 2: 积分模型与 Repository
- 输入：Step 1 的 schema
- 实现：Go struct Point + PointRepository
- 验证：单元测试覆盖 CRUD 操作
- 输出：internal/model/point.go + internal/repository/point.go

### Step 3: Service 层
- 输入：Step 2 的 Repository
- 实现：充值(recharge)、消费(spend)、查询(query) 业务逻辑
- 验证：测试覆盖 充值超限、余额不足、并发扣减 等边界

### Step 4: HTTP Handler
- 输入：Step 3 的 Service
- 实现：RESTful API
- 验证：curl 测试脚本通过

## 约束
- 所有金额用 int64（单位：分）
- 不允许出现负数余额
- 并发场景使用数据库行锁

生成器严格按 CONTRACT.md 执行，评估器也严格按 CONTRACT.md 写测试。两者完全不共享上下文中"怎么做"的信息——生成器只需要知道"做什么"，评估器也只需要知道"做什么"，各自独立判断"做得怎样"。

实际效果：

Anthropic 内部测试显示，引入三体架构后：

• 生成的代码首次通过测试率提升约 35%
• 安全漏洞检出率提升约 50%
• 代码风格一致性提升约 40%
• 每轮平均 token 消耗增加约 60%（这是代价）

5.3 对话式调试：当循环跑偏了怎么办

无论架构多好，循环迟早会跑偏。最常见的情况：

1. Agent 进入了死循环：反复修改同一个文件，每轮都说"找到了问题"，但就是修不好
2. Token 黑洞：Agent 在前几轮耗费了 80% 的预算，真正干活时没钱了
3. 越改越差：修一个 bug 引入两个新 bug

应对策略：

策略一：hard timeout 优先于 soft timeout

budget:
  max_iterations: 10       # soft limit
  max_runtime_minutes: 30  # hard limit - 到点截停
  max_tokens: 200000       # hard limit - 到量截停

至少设置一个硬性预算限制，并且要让 max_runtime_minutes 优先于 max_iterations 触发。

策略二：diff-based rollback

每一轮修改前，自动生成 diff 保存。如果本轮修改没有通过验证，自动 git checkout -- . 回退到上一轮的干净状态：

import subprocess

def safe_iteration(agent_func):
    """带自动回滚的安全迭代装饰器"""
    # 1. 记录当前状态
    subprocess.run(["git", "add", "-A"])
    subprocess.run(["git", "commit", "-m", "auto-snapshot-pre-iteration", "--allow-empty"])
    
    # 2. 执行 Agent
    result = agent_func()
    
    # 3. 验证
    if not validate(result):
        # 回滚
        subprocess.run(["git", "checkout", "HEAD~1", "--", "."])
        return None, "rolled back"
    
    return result, "ok"

策略三：sentinel file

在循环系统的根目录放一个 STOP 文件。如果运行过程中检测到这个文件存在，立即停止当前循环：

import os

def check_sentinel():
    """检查停止信号"""
    if os.path.exists(".loop/STOP"):
        graceful_shutdown()
        return True
    return False

# 在每个迭代步骤前检查
for i in range(max_iterations):
    if check_sentinel():
        break
    # ... 正常迭代

第六章：成本模型——Loop Engineering 的账本经济学

6.1 成本结构拆解

Loop Engineering 最大的争议点就是成本。Boris Cherny 和 Peter Steinberger 背后都有公司的无限 token 支持，但普通开发者面对的是每个月几百美元的 API 账单。

让我们拆解一个典型循环的成本结构：

单次迭代的成本公式：

单次迭代成本 = 
  系统 Prompt Token 数 × 单价
  + 上下文累积 Token 数 × 单价
  + 输入 Token 数 × 单价
  + 输出 Token 数 × 单价

以 Claude Sonnet（$3/M 输入，$15/M 输出）为例：

一个 Plann-Execute-Verify 循环跑 10 轮，单 Agent 大约 $1，三体架构约 $3。听起来不多？但考虑以下场景：

• 一个 Lifecycle Loop 每天跑 48 轮，月度成本 = $3 × 30 × (48/10) ≈ $432
• 同时运行 5 个循环，月成本 ≈ $2,160
• 加上 Anthropic 的 Routines 服务器费用再加 30-50%

结论：Loop Engineering 是真金白银的工程，不是免费午餐。

6.2 成本优化策略

策略一：一次验证降级

对于简单的任务，不需要完整的三体架构。可以用一次轻量级验证替代：

重执行 → 一次编译 → 编译通过 → 结束
                            ↓ 编译失败
                  返回错误信息 → 重执行

相比三体架构，这种方案省去了独立的评估器和规划器消耗，大约节省 50-60% 的 token。

策略二：有限迭代 + 人工接管

不要让循环无限重试。设置一个合理的迭代上限，超过上限后打标记交给人处理：

escalation:
  after_iterations: 5     # 5 轮没搞定，升级
  notify: "slack:#dev"
  severity: "warning"

实践中，绝大多数能在 3 轮内完成。如果 5 轮还没完成，说明任务定义有问题或者超出了 Agent 的能力边界。

策略三：差异化模型选择

在循环的不同阶段使用不同价位的模型：

stages:
  planning:
    model: "claude-sonnet"      # 规划需要思路清晰，用好模型
    max_tokens: 10000
  execution:
    model: "deepseek-v3"        # 执行可接受稍便宜的模型
    max_tokens: 30000
  verification:
    model: "claude-sonnet"      # 验证需要准确性
    max_tokens: 5000

深挖一下：DeepSeek V3 的 API 价格大约是 Claude Sonnet 的 1/5。如果你把执行阶段从 Sonnet 切到 DeepSeek，执行成本直接降 80%。当然，输出质量也略有下降，但对于"写样板代码"这类任务，性价比极高。

策略四：结果缓存

对于重复触发的循环（如每隔 15 分钟检查 CI 状态），如果自上次检查以来没有新的 commit，直接返回缓存结果：

def cached_iteration(task_key: str, ttl_seconds: int = 300):
    """带缓存的循环迭代"""
    cache_key = f"loop_cache:{task_key}"
    
    # 检查缓存
    cached = redis.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # 执行循环
    result = run_iteration(task_key)
    
    # 写缓存
    redis.setex(cache_key, ttl_seconds, json.dumps(result))
    return result

6.3 投资回报率分析

所以，Loop Engineering 值得吗？我们来算一笔账：

投入（每月）：

• API 费用：$300-500（中等规模）
• 系统设计时间：第一个月约 40 小时（设计循环架构、调试）
• 持续运维：每周约 5 小时（审查日志、调整参数）

产出（数量化估计）：

• 自动 PR 审查：每周节省 15-20 小时（假设团队 5 人，每人每天 review 30 分钟）
• CI 修复自动化：每周节省 8-10 小时
• 依赖升级自动化：每月节省 4-6 小时
• 代码生成：速度提升 2-3 倍（但不是 1:1 替代，因为 review 还是需要人的）

ROI 计算（6 个月维度）：

投入成本：$300 × 6 + 40 × $50 + 120 × $50 = $1,800 + $2,000 + $6,000 = $9,800
节约成本：(75 + 45 + 12) × $50 × 6 = $39,600
ROI = ($39,600 - $9,800) / $9,800 = 304%

6 个月 ROI 约 300%。对于 5-10 人的开发团队来说，这是一个值得投入的数字。对于个人开发者，ROI 要低得多——尤其是考虑到你的循环系统也是需要维护的工程资产。

第七章：生产级部署——从实验到使命关键

7.1 安全边界

将循环系统部署到生产环境，需要面对几个残酷的安全问题：

问题一：Agent 越界

如果没有限制，Agent 可以执行任何命令——包括 rm -rf /、修改生产数据库、向客户发送邮件。循环系统的自我复现能力使这类风险加倍，因为一个失控的循环会在你睡觉时持续"搞破坏"。

解决：沙箱执行环境

# loop 安全配置
security:
  sandbox:
    type: "docker"
    image: "ubuntu:24.04"
    readonly_fs: true
    network: "isolated"
    mounts:
      - source: "/repo"
        target: "/workspace"
        readonly: true
  
  allowed_commands:
    - "git"
    - "go build"
    - "go test"
    - "npm run build"
    - "pnpm lint"
  
  restricted_commands:
    - "rm -rf"
    - "chmod"
    - "curl --data"
    - "kubectl delete"

问题二：凭据泄漏

Agent 可能不小心将 API Key、数据库密码写入日志或输出内容。循环系统因为反复执行，泄漏风险成倍增加。

解决：凭据沙箱 + 输出过滤

import re

class CredentialFilter:
    """输出过滤器 - 自动遮蔽敏感信息"""
    
    PATTERNS = [
        (r'(?i)(api[_-]?key|token|secret|password)\s*[:=]\s*["\']?([^"\'&\s]+)', 
         r'\1: [REDACTED]'),
        (r'[A-Za-z0-9+/]{40,}={0,2}', '[POTENTIAL_TOKEN]'),
        (r'-----BEGIN (RSA |EC )?PRIVATE KEY-----', '[PRIVATE KEY BLOCKED]'),
    ]
    
    @classmethod
    def sanitize(cls, text: str) -> str:
        for pattern, replacement in cls.PATTERNS:
            text = re.sub(pattern, replacement, text)
        return text

问题三：权限膨胀

循环系统运行久了，你可能不知不觉给了它越来越多的权限。"上周需要执行 sudo 来装一个包，那权限就保留吧"——然后下周就出了问题。

解决：最小权限周期审查

每 30 天自动生成一份权限审计报告：

# 权限审计命令
loopctl audit --days 30
# 输出示例：
# 循环：auto-deploy
#   新增允许的 SSH 主机：3
#   新增允许的 API 端点：7
#   建议审查：database write 权限（最近未使用）

7.2 监控与可观测性

循环系统是"黑灯工厂"式的自动化，管理者看不到内部运转。因此，监控必须比传统应用更精细。

指标三要素：

monitoring:
  metrics:
    # 业务指标
    - name: "loop_success_rate"
      type: "counter"
      description: "循环成功完成率"
    
    - name: "loop_iterations_per_run"  
      type: "histogram"
      description: "每次触发所需的平均迭代次数"
    
    - name: "token_consumption_per_run"
      type: "gauge"
      description: "每次运行的 token 消耗"
    
    # 异常指标
    - name: "loop_escalated_runs"
      type: "counter"
      description: "需要人工介入的次数"
    
    - name: "loop_rollback_count"
      type: "counter"
      description: "自动回滚次数"
    
    # 成本指标
    - name: "loop_daily_cost_usd"
      type: "gauge"
      description: "循环系统每日 API 费用"

日志规范：

循环的日志需要比普通应用更结构化，因为你不能期待开发者去读 AI 生成的原始文本：

{
  "timestamp": "2026-07-04T14:39:00Z",
  "loop_id": "auto-code-review",
  "iteration": 3,
  "stage": "execution",
  "tokens_used": 4521,
  "cumulative_tokens": 18230,
  "status": "in_progress",
  "current_action": "修改 internal/handler/user.go 第 142 行",
  "last_error": null,
  "estimated_remaining_iterations": 2
}

7.3 回滚与容错

循环系统最容易出问题的时刻，不是部署后的第一周，而是运行一个月后——某个日常运行的循环突然出了问题，但你不确定它从什么时候开始跑的偏了。

快照机制：

snapshots:
  # 每轮迭代前备份工作目录
  strategy: "git"
  auto_commit: true
  max_snapshots: 100
  retention_days: 7
  
  # 每次修改前记录 diff
  diff_log: ".loop/diffs/{timestamp}.patch"

结合之前提到的 diff-based rollback，这实际上是给了你一个"时间机器"：

# 回滚到第 23 轮之前的状态
loopctl rollback --loop auto-deploy --to-iteration 23

第八章：生态全景与未来展望

8.1 当前生态对比

8.2 与 Karpathy Skills 的关系

有读者可能会问：Karpathy Skills 不也是给 AI 编程设计的四原则吗？Loop Engineering 和它是什么关系？

它们是互补而非替代的关系。

Karpathy Skills 定义了 Agent 内部的行为原则 —— Think Before Coding（先想后写）、Simplicity First（简单优先）、Surgical Changes（精准修改）、Goal-Driven Execution（目标驱动）。这是一套指导 Agent"怎么写好代码"的内部规范。

Loop Engineering 定义了 Agent 外部的系统架构 —— 设计循环触发 Agent，而不是手动 prompt。这是指导开发者"怎么让 Agent 持续运行"的外部系统设计。

换句话说：

• Karpathy Skills 是 Agent 的内功心法——怎么把代码写好
• Loop Engineering 是 Agent 的江湖体系——怎么让 Agent 持续工作

两者结合，才是完整的 AI 编程方法论。

8.3 未来展望

短期（6 个月）：Claude Code、Codex、Grok 等主流 Agent 工具将原生集成完整的 Loop 管理界面。你可以在 GUI 中创建、监控和管理循环，类似今天的 CI/CD 管道视图。

中期（1-2 年）：出现标准化的 Loop 定义规范（类似 OpenAPI），让循环定义可以跨工具跨平台复用。届时你写一个 loop.yaml，Claude Code 能跑、Cursor 能跑、Codex 也能跑。

长期（3-5 年）：Loop Engineering 成为软件开发的标配技能。正如今天的开发者都知道"单元测试是必须的"，明天的开发者都知道"循环设计是必须的"。软件工程的课程大纲里，"循环工程"将与"需求分析""系统设计""测试工程"并列。

结语：从 Prompt 工匠到循环架构师

Loop Engineering 的出现不是偶然。它是 AI 工程能力到达一定水平后，开发者对"效率最大化"的自然追求。

回头看最近四年的 AI 编程进化史：

• 2023 年：我们在学习怎么写好 prompt，像刚拿到锤子的人到处找钉子
• 2024 年：我们发现了上下文的重要性，开始给 Agent 喂项目背景
• 2025 年：我们给 Agent 套上了 harness，让它们更可控
• 2026 年：我们意识到，最有价值的不是"写好一次 prompt"，而是"设计好一个能持续自我提升的系统"

最重要的事情在最后：如果你现在刚开始接触 Loop Engineering，我的建议不是立刻跑一个复杂的 5 模式 3 Agent 循环。先用手头的工具，试一个最简单的 Retry Loop——比如"每 5 分钟检查一次构建状态，失败时自动修复"。跑起来，观察成本，记录效果，然后迭代。

Loop Engineering 本身就是一个循环。你的第一次尝试可能不够好，但设计者有足够的信息和经验去改进它。这才是循环的本质——持续迭代，永不停止。

一如 Boris Cherny 所说：

"I don't prompt Claude anymore. I have loops running that prompt Claude."

你不是开发者，你是循环架构师。

附录

A. 推荐的 VISION.md 模板

# VISION.md - 循环系统的目标与约束

## 这个循环应该做什么
- [用一句话描述核心目标]

## 边界约束
- 绝不修改：生产数据库、核心配置、安全敏感文件
- 修改前必须：足够覆盖的测试已运行通过
- 自动回滚条件：测试覆盖率下降、核心业务流程不通

## 停止条件
- 任务完成且通过所有验证
- 超过最大迭代次数（默认：5）
- 累计 token 超过预算（默认：200K）
- 运行时间超过限制（默认：30分钟）
- 检测到 STOP 信号（.loop/STOP 文件）

## 升级流程
如果循环无法在预算内完成任务：
1. 记录所有尝试过的方案
2. 标记失败原因（任务定义不清？能力不足？预算不够？）
3. 通知指定渠道

## 成本目标
- 单次完整运行 ≤ $3
- 月度总预算：$200

B. 参考资源

• Addy Osmani, "Loop Engineering: The Next Frontier in AI Development", 2026
• Boris Cherny, "Building Loops for Claude Code", Anthropic Engineering Blog, 2026
• Peter Steinberger, "You Should Be Designing Loops", OpenClaw Blog, 2026
• 清华 NMRC, "OpenLoop: Universal Loop Engineering Framework", 2026
• Cobus Greyling, "loop-init: One-Command Loop Engineering", GitHub, 2026