1.2 核心概念：循环、验证器与自主性 — Loop Engineering 的三大基石

本节导读：深入理解 Loop Engineering 的三个核心概念——循环（Loop）、验证器（Verifier）与自主性（Autonomy），掌握它们如何协同工作构成循环工程的理论基础。

学习目标

• 理解循环的四大阶段（discover → plan → execute → verify）
• 掌握验证器在循环中的核心地位及设计原则
• 区分不同等级的自主性及其适用场景
• 理解"验证器是瓶颈"这一核心洞察

核心概念

一、循环：AI 的控制流

AI Builder Club 的定义精炼到位："Loop engineering is the discipline of designing the loop an agent runs inside - what it does between tool calls, when it checks its own work, and how it decides it's finished - instead of hand-writing each prompt."

（循环工程是一门设计 Agent 运行其中的循环的学科——它在工具调用之间做什么、何时检查自己的工作、如何判断已完成——而不是手动编写每一条提示词。）

剥离所有术语，一个循环就是四个动作的重复：

discover → plan → execute → verify → (repeat until condition met)

Discover（发现）：Agent 评估当前环境状态，了解"我现在在哪"。它读取代码、检查测试结果、扫描日志、查看 Issue 列表——任何能帮助它理解现状的信息。

Plan（规划）：基于发现的信息，Agent 决定下一步该做什么。这是 LLM 的推理环节——分析失败原因、确定修复策略、排列任务优先级。

Execute（执行）：Agent 采取行动——编辑代码、运行命令、创建文件、发送 API 请求。这一步是 Agent 与真实环境交互的环节。

Verify（验证）：Agent 检查执行结果是否接近目标。运行测试、检查类型、验证输出。验证的结果决定了循环是继续还是停止。

这种循环模式并非全新发明，它的学术祖先可以追溯到 ReAct 模式（Yao et al., 2022，来自普林斯顿和 Google 的研究），该模式将推理步骤与行动步骤交替进行，证明了"在行动之间观察结果的模型"与"一次性回答的模型"表现截然不同。

二、验证器：循环中最关键的组件

AI Builder Club 的一句话揭示了循环工程的核心洞察："In any loop, the verifier is the bottleneck, not the model."（在任何一个循环中，验证器是瓶颈，不是模型。）

这是什么意思？模型（LLM）的能力已经足够强了——它能理解任务、编写代码、分析错误。真正决定循环质量的是验证器——判断"做得好不好"和"做没做完"的那个组件。

弱验证器（模型自评）：让编写代码的同一个模型评判自己的输出。问题在于——模型对自己的代码"太宽容了"（way too nice grading its own homework）。它会说自己的代码是对的，即使里面有 bug。

中验证器（确定性工具检查）：运行测试套件、lint 检查、类型检查器。这些是确定性的——结果只有通过或失败，不存在主观判断。这是大多数循环的基线验证方式。

强验证器（独立子代理评审）：启动一个独立的 Agent，用不同的指令（甚至不同的模型）来评审第一个 Agent 的工作。Claude Code 的 /goal 底层机制正是如此——一个独立的小模型判断循环是否完成，而不是完成工作的那个模型自己打分。

终极验证器（人工审查）：循环做的是准备和初筛，最终的代码审查仍然由人类完成。Addy Osmani 的观点始终是："Your job is to ship code you confirmed works."（你的工作是交付你确认可以工作的代码。）

三、自主性：从手动到全自动的光谱

自主性不是一个二元开关，而是一个光谱。理解这个光谱有助于你为不同任务选择合适的循环设计：

循环工程的目标不是盲目追求 Level 3，而是在合适的地方选择合适的自主等级。

环境准备 / 前置知识

• 已阅读 1.1 节，了解 Loop Engineering 的基本定义
• 理解基本的编程循环概念（for/while）
• 了解测试驱动开发（TDD）的基本思想

分步实战

步骤 1：设计你的第一个验证器

验证器的质量决定了循环的质量。我们从最简单的确定性验证器开始：

"""verifier_design.py - 验证器设计示例"""
from dataclasses import dataclass
from typing import Literal

@dataclass
class VerifyResult:
    """验证结果数据结构"""
    passed: bool
    score: float          # 0.0 ~ 1.0
    details: str          # 详细信息
    action: Literal["continue", "stop", "escalate"]  # 下一步动作

def test_suite_verifier(project_path: str) -> VerifyResult:
    """
    Level 2 验证器：确定性测试检查
    最可靠且最常用的验证方式
    """
    import subprocess

    result = subprocess.run(
        ["npm", "test", "--", "--json"],
        cwd=project_path,
        capture_output=True, text=True
    )

    if result.returncode == 0:
        return VerifyResult(
            passed=True,
            score=1.0,
            details="所有测试通过",
            action="stop"
        )

    # 分析失败情况
    total = result.stdout.count("✓") + result.stdout.count("✗")
    failed = result.stdout.count("✗")
    pass_rate = (total - failed) / max(total, 1)

    return VerifyResult(
        passed=False,
        score=pass_rate,
        details=f"通过 {total-failed}/{total}，失败 {failed}",
        action="continue" if pass_rate > 0.5 else "escalate"
    )

def multi_verifier(project_path: str) -> VerifyResult:
    """
    组合验证器：运行多个检查维度
    """
    results = []

    # 1. 测试套件
    test_result = test_suite_verifier(project_path)
    results.append(("测试", test_result))

    # 2. Lint 检查
    lint = subprocess.run(
        ["npx", "eslint", ".", "--quiet"],
        cwd=project_path,
        capture_output=True, text=True
    )
    lint_passed = lint.returncode == 0
    results.append(("Lint", VerifyResult(
        passed=lint_passed,
        score=1.0 if lint_passed else 0.5,
        details="Lint 通过" if lint_passed else f"发现 {lint.stdout.count('error')} 个错误",
        action="continue"
    )))

    # 综合判断
    all_passed = all(r.passed for _, r in results)
    avg_score = sum(r.score for _, r in results) / len(results)

    details = "; ".join(f"{name}: {r.details}" for name, r in results)

    return VerifyResult(
        passed=all_passed,
        score=avg_score,
        details=details,
        action="stop" if all_passed else "continue"
    )
​

步骤 2：实现自主循环引擎

"""autonomous_loop.py - 自主循环引擎"""
import time

def run_autonomous_loop(
    goal: str,
    verifier_func,
    max_iterations: int = 10,
    max_time_seconds: int = 600
):
    """
    自主循环引擎，集成验证器和停止条件
    """
    start_time = time.time()
    history = []

    for i in range(max_iterations):
        # 超时检查
        elapsed = time.time() - start_time
        if elapsed > max_time_seconds:
            return {
                "status": "timeout",
                "message": f"超过 {max_time_seconds}s 时间限制",
                "iterations": i
            }

        print(f"\n{'='*50}")
        print(f"循环第 {i+1} 轮 | 已用时 {elapsed:.0f}s")
        print(f"目标: {goal}")
        print(f"{'='*50}")

        # DISCOVER + PLAN + EXECUTE (交给 AI Agent)
        # 这里是简化示例，实际中调用 LLM API
        print("→ Agent 正在分析和执行...")

        # VERIFY
        result = verifier_func()
        print(f"→ 验证结果: {result.details} (得分: {result.score:.1%})")
        history.append(result)

        # 决定下一步
        if result.action == "stop":
            return {
                "status": "success",
                "message": "目标达成",
                "iterations": i + 1,
                "time": elapsed
            }
        elif result.action == "escalate":
            return {
                "status": "escalated",
                "message": "验证器建议升级给人工处理",
                "iterations": i + 1,
                "time": elapsed,
                "last_result": result.details
            }

        # 无进展检测
        if len(history) >= 3:
            recent_scores = [h.score for h in history[-3:]]
            if max(recent_scores) - min(recent_scores) < 0.05:
                return {
                    "status": "stuck",
                    "message": "连续 3 轮无明显进展",
                    "iterations": i + 1,
                    "time": elapsed
                }

    return {
        "status": "max_iterations",
        "message": f"达到最大迭代次数 {max_iterations}",
        "iterations": max_iterations
    }
​

步骤 3：测试不同自主性等级

# Level 0: 手动 - 每步都要确认
#（你在聊天框里手动输入每一条指令）

# Level 2: 受监督自动 - 自动执行，你审查结果
result = run_autonomous_loop(
    goal="让所有测试通过且 lint 清洁",
    verifier_func=lambda: multi_verifier("/path/to/project"),
    max_iterations=6
)

# Level 3: 全自动 - 定时运行，仅在异常时通知
#（通过 cron 或 Claude Code automations 设置定时执行）
​

常见问题 FAQ

Q1：为什么验证器比模型更重要？模型不是核心吗？

A：模型的能力是循环的必要条件，验证器的质量是循环的充分条件。一个足够好的模型 + 一个差验证器 = 循环要么永远不停（验证器太宽松），要么过早停止（验证器太严格）。一个中等模型 + 一个好验证器 = 循环虽然慢一些但能可靠收敛。实际经验表明，到 2026 年，模型已经足够好了——瓶颈确实在验证器设计上。

Q2：如何避免模型对自己的输出评分过高？

A：Maker-Checker 分离是核心策略。最简单的方法是使用确定性工具（测试套件、lint）作为验证器，而不是让模型自己评自己。进阶方法是启动一个独立的子代理，用不同的系统指令来评审。Claude Code 的 /goal 就是这么做的——一个独立的小模型判断循环是否完成。

Q3：什么情况下应该选择 Level 0（手动）而不是全自动循环？

A：以下情况适合保持手动：(1) 你还不理解任务领域，循环会帮你自动化你不理解的东西；(2) 任务涉及安全敏感操作（数据库删除、生产环境部署）；(3) 需求本身还不明确，循环需要一个稳定的目标才能可靠运行。先手动几次理解模式，再设计循环。

最佳实践与避坑

• 验证器要确定性：尽可能用可自动检查的标准（测试通过率、编译成功、lint 0 error），减少主观判断
• Maker-Checker 分离：永远不要让同一个 Agent 同时编写和验证代码
• 多重验证：测试 + lint + 类型检查，组合使用比单一验证更可靠
• 设置兜底：最大迭代次数、时间限制、无进展检测，三重保险防止循环失控
• 渐进式自主：从 Level 1 开始，验证循环可靠后再逐步提高自主性

本节小结

本节深入解析了 Loop Engineering 的三大核心概念：循环的四阶段模式（discover→plan→execute→verify）、验证器作为循环瓶颈的核心洞察、以及从手动到全自动的自主性光谱。理解这三个概念是掌握循环工程的基础。

下一节我们将动手搭建环境，体验你的第一个 Loop，从实践中感受循环工程的威力。

延伸阅读

• Oracle: What Is the AI Agent Loop
• MindStudio: Loop Engineering for Autonomous AI Agents
• 相关章节：1.3 环境搭建与快速入门

关键词：Loop Engineering, 循环工程, 验证器设计, Verifier, ReAct 模式, Maker-Checker 分离, 自主性等级, Agent 循环, 教程, 实战

难度：入门

预计阅读：15 分钟