一、引言

2025年初，Andrej Karpathy提出“Vibe Coding”时，AI编程尚处于“手动挡”阶段——开发者通过多轮对话引导AI生成代码，每一次迭代都依赖人的判断与指令。然而不到两年，这一模式正在被一种全新的范式所取代，它被称为“循环工程”（Loop Engineering）。

如果说Vibe Coding是AI编程的“手动驾驶”，那么循环工程就是“自动驾驶”——开发者不再逐轮参与对话循环，而是构建一个能够自主运行、自我纠错、持续迭代的闭环系统。在这个系统中，AI Agent承担起“计划→执行→验证→修正”的完整链条，而人类则从“驾驶员”转变为“系统架构师”。

循环工程并非某一项单一技术，而是一套以Agent自主循环为核心、以内置质量门为保障、以工具生态为支撑的新型软件开发方法论。它正在重塑AI编程的生产关系，也将成为智能体工程（Agentic Engineering）落地的核心载体。

---

二、循环工程的本质：从“人驱动循环”到“循环驱动人”

2.1 传统AI编程的“回合制”困境

在Vibe Coding模式下，典型的开发流程是：

1. 开发者输入需求 → 2. AI生成代码 → 3. 开发者检查 → 4. 发现问题 → 5. 修改提示词 → 6. 重新生成 → 7. 验证 → ……

这是一个以人为中心的多轮对话循环，人的注意力和决策速度成为瓶颈。对于中等复杂度任务，往往需要20-50轮对话，每轮消耗数分钟。更关键的是：人必须全程盯守，无法并行处理多任务。

2.2 循环工程的定义

循环工程将上述循环从“人-AI对话”重构为“AI自主闭环”。其核心范式是：

开发者设定目标、约束条件和质量标准 → AI系统自动执行“规划→编码→测试→分析→修正”的迭代 → 仅在关键决策点或异常时请求人工介入。

在循环工程中，循环本身是第一类工程对象。开发者不再编写“这段代码做什么”，而是编写“这个Agent循环应该怎么运行、怎么判断成功、怎么处理失败”。

---

三、循环工程的技术架构

3.1 核心组件

一个典型的循环工程系统由以下模块构成：

组件	功能	示例实现
任务规划器	将高层目标拆解为可执行的子任务	基于思维链（CoT）的Agent
执行引擎	调用工具完成编码、文件操作、命令执行	工具调用框架（Tool Calling）
验证器	运行测试、检查语法、评估输出质量	单元测试框架、静态分析工具
反思器	分析失败原因，生成修正方案	基于错误信息的自纠正Prompt
记忆模块	存储历史尝试和成功模式	向量数据库 + RAG

3.2 循环工程的核心算法

循环工程的核心逻辑可形式化表示为：

给定目标 G 和初始上下文 C0：
for iteration t = 0, 1, 2, ... until success:
    P_t = Planner(G, C_t, History)       # 生成计划
    Code_t = Executor(P_t)               # 执行编码
    Result_t = Verifier(Code_t)          # 运行测试/验证
    if Result_t == PASS:
        return Code_t                    # 成功
    else:
        Feedback_t = Reflector(Result_t, Code_t)  # 生成修正反馈
        C_{t+1} = Update(C_t, Feedback_t)         # 更新上下文
        continue

这一循环可无限运行，直到目标达成或达到最大尝试次数。

---

四、循环工程的代码实现

以下是一个基于LangChain和OpenAI工具调用构建的简易循环工程Agent实现示例：

import json
from typing import List, Dict
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
import subprocess
import tempfile

# 工具1：编写代码到文件
def write_code(filename: str, code: str) -> str:
    with open(filename, "w") as f:
        f.write(code)
    return f"代码已写入 {filename}"

# 工具2：运行Python测试
def run_python_test(filename: str) -> str:
    try:
        result = subprocess.run(
            ["python", filename], 
            capture_output=True, 
            text=True, 
            timeout=10
        )
        if result.returncode == 0:
            return f"测试通过: {result.stdout}"
        else:
            return f"测试失败: {result.stderr}"
    except Exception as e:
        return f"执行异常: {str(e)}"

# 工具3：分析错误并生成修复建议（模拟）
def analyze_error(error_log: str) -> str:
    # 实际应用中可调用LLM进行错误分析
    return f"错误分析: {error_log[:200]}... 建议检查变量类型或空值处理。"

tools = [
    Tool(name="WriteCode", func=write_code, description="将代码写入文件"),
    Tool(name="RunTest", func=run_python_test, description="执行Python文件并返回结果"),
    Tool(name="AnalyzeError", func=analyze_error, description="分析错误日志")
]

# 构建循环Agent
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个循环工程Agent。你的任务是：编写代码→运行测试→分析失败→修正代码，重复此循环直到测试通过。"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

llm = ChatOpenAI(model="gpt-4", temperature=0.2)
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=10)

# 启动循环工程任务
if __name__ == "__main__":
    goal = """编写一个Python函数，计算斐波那契数列的第n项，要求：
    1. 支持n为非负整数
    2. 对n=0返回0，n=1返回1
    3. 使用递归实现，并添加缓存优化
    4. 编写测试用例验证功能
    """
    result = executor.invoke({"input": goal})
    print("最终输出:", result["output"])

4.2 更复杂的循环：带反思机制的自纠正循环

class LoopEngineeringAgent:
    def __init__(self, llm, max_loops=20):
        self.llm = llm
        self.max_loops = max_loops
        self.history = []
    
    def run(self, goal: str) -> Dict:
        context = {"goal": goal, "attempts": []}
        
        for i in range(self.max_loops):
            # 1. 规划阶段
            plan = self.plan(context)
            # 2. 执行阶段
            code = self.execute(plan)
            # 3. 验证阶段
            test_result = self.verify(code)
            
            if test_result["passed"]:
                return {"success": True, "code": code, "iterations": i+1}
            
            # 4. 反思阶段
            reflection = self.reflect(test_result, code)
            context["attempts"].append({
                "iteration": i+1,
                "code": code,
                "error": test_result["error"],
                "reflection": reflection
            })
            
            # 5. 更新上下文，准备下一轮
            context["last_error"] = test_result["error"]
            context["last_reflection"] = reflection
        
        return {"success": False, "iterations": self.max_loops, "history": context["attempts"]}
    
    def plan(self, context):
        # 使用LLM生成计划
        prompt = f"目标: {context['goal']}\n历史尝试: {context['attempts'][-3:] if context['attempts'] else '无'}\n请制定下一步计划。"
        return self.llm.invoke(prompt)
    
    def execute(self, plan):
        # 模拟执行（实际调用代码生成+文件操作）
        return "def fib(n): return n if n<2 else fib(n-1)+fib(n-2)"
    
    def verify(self, code):
        # 模拟验证（实际运行测试）
        return {"passed": True if "fib" in code else False, "error": "" if "fib" in code else "函数名错误"}
    
    def reflect(self, test_result, code):
        prompt = f"代码: {code}\n错误: {test_result.get('error', '')}\n请分析根本原因。"
        return self.llm.invoke(prompt)

# 使用示例
agent = LoopEngineeringAgent(llm=ChatOpenAI(), max_loops=10)
result = agent.run("实现一个快速排序算法")
print(f"成功: {result['success']}, 迭代: {result.get('iterations', 'N/A')}")

---

五、循环工程的关键挑战与设计原则

5.1 三大挑战

1. 无限循环与收敛性问题：如何设计终止条件（如“测试通过率>95%”、“代码覆盖率达标”）？
2. 错误传播与放大：错误的修正可能引入新错误，需引入检查点与回滚机制。
3. 成本与效率的平衡：自主循环可能消耗大量API调用，需设置预算上限和智能的“早停”策略。

5.2 工程实践原则

• 质量门内建：在每个循环阶段设置确定性检查（语法检查、静态类型检查、单元测试覆盖率门槛）。
• 审计轨迹：记录每一轮的代码、测试输出和反思日志，便于事后分析和人工介入。
• 人工回退点：设置关键里程碑（如“经过5轮仍未通过”），自动暂停并请求人工评审。
• 缓存与知识复用：将成功的修正模式存入向量数据库，供后续循环检索借鉴。

---

六、循环工程的应用场景

1. 自动化代码重构：Agent自主分析遗留系统，逐步替换废弃API，确保测试全部通过。
2. 持续集成修复：当CI构建失败时，循环Agent自动分析日志、生成修复补丁、提交PR。
3. 测试用例生成与扩增：给定函数签名，循环生成测试用例，评估覆盖率，补全缺失分支。
4. 漏洞修复与安全加固：自动扫描代码库，识别SQL注入等漏洞，生成补丁并验证。

---

七、结语

循环工程的兴起标志着AI编程从“辅助工具”迈向“自主生产力”的关键转折。它不再将AI视为一个被动的代码生成器，而是一个能够持续试错、自我纠正的“虚拟工程师”。

然而，循环工程并非要取代人类，而是将人类的精力从“循环内部”解放到“循环设计”上。未来的开发者将花费更多时间在定义目标、设置质量门、设计Agent协作协议上，而把重复的尝试、测试、修正交给循环系统自主完成。

正如自动驾驶从L2进化到L4一样，循环工程也将经历从“半自动”到“高度自动”的演进。当循环可以跨会话、跨项目、跨团队持续运行时，AI编程的真正“自动驾驶”时代才刚刚拉开序幕。