4.1 软件开发中的循环工程实践：Bug修复、功能开发与代码审查自动化

导读：软件开发是循环工程最天然的应用场景。本节将Bug修复、功能开发、代码审查和重构转化为AI自主循环驱动的自动化流程，通过discover→plan→execute→verify四阶段模型，让Agent在每一步自主决策和迭代。

学习目标

• 理解软件开发四大核心循环的结构差异与终止条件
• 掌握用Claude Code /goal模式实现Bug修复循环
• 设计功能开发循环的自动化框架
• 构建代码审查循环的规则引擎
• 了解重构循环的测试不退化保障机制

核心概念

软件开发循环遵循Loop Engineering四阶段模型。根据输入类型不同，自动调度到四种循环之一：

四种循环关键对比：

环境准备

前置知识：Python基础、Git操作、单元测试概念、Loop Engineering四阶段模型

工具安装：

pip install pytest pytest-cov gitpython
npm install -g @anthropic-ai/claude-code  # 可选但推荐
​

分步实战

步骤一：Bug修复循环框架

Bug修复是最常见的循环应用。以下实现完整的四阶段框架：

"""bug_fix_loop.py — Bug修复循环引擎"""
import os, json, subprocess, re, time
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path

class Phase(Enum):
    DISCOVER = "discover"; PLAN = "plan"
    EXECUTE = "execute"; VERIFY = "verify"

class Status(Enum):
    SUCCESS = "success"; FAILED = "failed"; ESCALATED = "escalated"

@dataclass
class BugReport:
    bug_id: str; title: str; description: str
    steps_to_reproduce: list[str]
    expected_behavior: str; actual_behavior: str
    severity: str = "medium"
    files_affected: list[str] = field(default_factory=list)
    error_logs: str = ""

@dataclass
class Iteration:
    num: int; phase: Phase; action: str
    result: str; artifacts: dict = field(default_factory=dict)

@dataclass
class LoopResult:
    status: Status; iterations: int
    history: list[Iteration] = field(default_factory=list)

class BugFixLoop:
    def __init__(self, project_root: str, max_iter: int = 8,
                 test_cmd: str = "pytest"):
        self.root = Path(project_root)
        self.max_iter = max_iter
        self.test_cmd = test_cmd
        self.history: list[Iteration] = []

    def run(self, bug: BugReport) -> LoopResult:
        for i in range(1, self.max_iter + 1):
            print(f"\n🔄 迭代 #{i}/{self.max_iter}")
            
            # DISCOVER: 定位相关文件和错误模式
            keywords = self._extract_keywords(bug)
            files = self._search_files(keywords)
            if not files:
                files = self._broad_search()[:15]
            if not files:
                return LoopResult(Status.ESCALATED, i, self.history[:])
            
            patterns = re.findall(r'\w+Error', bug.error_logs)
            self.history.append(Iteration(i, Phase.DISCOVER,
                f"关键词:{keywords}", f"文件:{len(files)} 错误模式:{patterns}",
                {"files": files, "patterns": patterns}))
            
            # PLAN: 制定修复方案
            fix_plan = {"targets": files[:3], "type": self._classify(bug),
                        "strategy": "targeted"}
            self.history.append(Iteration(i, Phase.PLAN, "制定方案",
                json.dumps(fix_plan, ensure_ascii=False), {"plan": fix_plan}))
            
            # EXECUTE: AI Agent执行（框架阶段）
            print(f"  🔍 发现{len(files)}文件 → 📋 方案 → 🔨 执行")
            self.history.append(Iteration(i, Phase.EXECUTE, "Agent修改",
                "代码已修改", {"modified": files[:3]}))
            
            # VERIFY: 运行测试
            test_ok = self._run_tests()
            self.history.append(Iteration(i, Phase.VERIFY, "测试验证",
                "PASS" if test_ok else "FAIL", {}))
            
            if test_ok:
                print(f"  ✅ 修复成功（{i}次迭代）")
                return LoopResult(Status.SUCCESS, i, self.history[:])
            print(f"  ❌ 测试失败，继续循环...")
            bug.error_logs += f"\n迭代{i}失败"
        
        return LoopResult(Status.FAILED, self.max_iter, self.history[:])

    def _extract_keywords(self, bug: BugReport) -> list[str]:
        text = f"{bug.title} {bug.description} {bug.error_logs}"
        words = re.findall(r'[a-zA-Z_]{4,}', text)
        stops = {'the','this','that','with','from','have','been','were'}
        return list(set(w for w in words if w.lower() not in stops))[:8]

    def _search_files(self, keywords: list[str]) -> list[str]:
        found = set()
        for kw in keywords[:4]:
            try:
                r = subprocess.run(["grep","-rl","--include=*.py",kw,
                    str(self.root)], capture_output=True, text=True, timeout=10)
                for f in r.stdout.strip().split('\n'):
                    if f: found.add(os.path.relpath(f, self.root))
            except: continue
        return list(found)

    def _broad_search(self) -> list[str]:
        try:
            r = subprocess.run(["find",str(self.root),"-name","*.py",
                "-type","f"], capture_output=True, text=True, timeout=10)
            return [os.path.relpath(f,self.root)
                    for f in r.stdout.strip().split('\n') if f]
        except: return []

    def _classify(self, bug: BugReport) -> str:
        log = bug.error_logs
        if "KeyError" in log: return "键错误"
        if "TypeError" in log: return "类型错误"
        if "ImportError" in log: return "依赖问题"
        return "功能缺陷"

    def _run_tests(self) -> bool:
        try:
            r = subprocess.run(self.test_cmd.split(), cwd=self.root,
                capture_output=True, text=True, timeout=300)
            return r.returncode == 0
        except: return False

# 使用
if __name__ == "__main__":
    loop = BugFixLoop("/path/to/project")
    bug = BugReport(bug_id="BUG-1", title="邮箱验证失败",
        description="大写邮箱验证不通过",
        steps_to_reproduce=["输入TEST@EXAMPLE.COM"],
        expected_behavior="验证成功", actual_behavior="验证失败",
        files_affected=["users/service.py"],
        error_logs="ValueError: Invalid email")
    print(loop.run(bug).status.value)
​

步骤二：Claude Code /goal 实战

Claude Code的/goal是Bug修复循环的最佳工具。它内部自动完成整个循环：

$ claude
> /goal "修复 users/service.py 中 register_user 邮箱大小写验证Bug，添加测试"

🤖 分析中...
📋 DISCOVER: 定位 users/service.py, tests/test_users.py
🔨 PLAN: 在validate_email中添加.lower()转换
🔨 EXECUTE: 修改代码 + 添加测试用例
✅ VERIFY: pytest PASSED (7/7)
🎉 完成！1次循环
​

Claude Code循环的关键特性：自动创建worktree隔离、失败时自动重试不同方案、达到上限后自动升级。

步骤三：代码审查循环

代码审查循环用规则引擎自动检测安全、逻辑、性能问题：

"""code_review_loop.py — 自动代码审查引擎"""
import subprocess, re
from dataclasses import dataclass
from enum import Enum
from pathlib import Path

class Sev(Enum):
    CRITICAL="critical"; HIGH="high"; MEDIUM="medium"; LOW="low"

RULES = {
    "security": [
        (r'eval\s*\(', "eval()代码注入风险", "用ast.literal_eval()", Sev.CRITICAL),
        (r'pickle\.load', "pickle任意代码执行", "用json替代", Sev.CRITICAL),
        (r'(password|secret|token)\s*=\s*["\'][^"\']+["\']', "硬编码敏感信息", "用环境变量", Sev.CRITICAL),
    ],
    "logic": [
        (r'except\s*:', "裸except捕获所有异常", "except Exception:", Sev.HIGH),
        (r'if\s+.+\s*=\s*[^=]', "可能误用=代替==", "检查是否应为==", Sev.HIGH),
    ],
    "style": [
        (r'def\s+\w+\s*\([^)]*\):\s*$', "空函数体", "添加pass", Sev.LOW),
    ]
}

@dataclass
class Issue:
    file: str; line: int; sev: Sev; cat: str
    title: str; fix: str

@dataclass
class ReviewResult:
    score: float; issues: list[Issue]; approved: bool

class CodeReviewLoop:
    def __init__(self, project_root: str, base: str = "main"):
        self.root = Path(project_root); self.base = base

    def review(self, branch: str) -> ReviewResult:
        diff = self._git_diff(branch)
        files = [f for f in re.findall(r'^diff --git a/(.+?) b/', diff, re.M) if f.endswith('.py')]
        issues = []
        for fp in files:
            for ln, content in self._added_lines(self._git_file_diff(branch, fp)).items():
                for cat, rules in RULES.items():
                    for pat, desc, fix, sev in rules:
                        if re.search(pat, content):
                            issues.append(Issue(fp, ln, sev, cat, desc, fix))
        issues.sort(key=lambda x: x.sev.value, reverse=True)
        score = max(0, 100 - sum({Sev.CRITICAL:30,Sev.HIGH:15,Sev.MEDIUM:5,Sev.LOW:2}[i.sev] for i in issues))
        return ReviewResult(score, issues, score>=70 and not any(i.sev==Sev.CRITICAL for i in issues))

    def _git_diff(self, branch): 
        try:
            r=subprocess.run(["git","diff",f"{self.base}...{branch}"],
                cwd=self.root,capture_output=True,text=True,timeout=30)
            return r.stdout
        except: return ""

    def _git_file_diff(self, branch, fp):
        try:
            r=subprocess.run(["git","diff",f"{self.base}...{branch}","--",fp],
                cwd=self.root,capture_output=True,text=True,timeout=30)
            return r.stdout
        except: return ""

    def _added_lines(self, diff: str) -> dict[int, str]:
        lines, cur = {}, 0
        for line in diff.split('\n'):
            if line.startswith('@@'):
                m = re.search(r'\+(\d+)', line)
                if m: cur = int(m.group(1))
            elif line.startswith('+') and not line.startswith('+++'):
                lines[cur] = line[1:]; cur += 1
            elif not line.startswith('-'): cur += 1
        return lines
​

完整示例：开发循环编排器

"""dev_orchestrator.py — 统一调度四种循环"""
import json, subprocess, time, re
from dataclasses import dataclass, field
from enum import Enum

class TaskType(Enum):
    BUG_FIX="bug_fix"; FEATURE="feature"; REVIEW="review"; REFACTOR="refactor"

@dataclass
class Task:
    type: TaskType; title: str; desc: str
    files: list[str] = field(default_factory=list)

@dataclass
class Config:
    max_iter: int = 8; test_cmd: str = "pytest -x"

class Orchestrator:
    def __init__(self, root: str, cfg: Config = None):
        self.root = root; self.cfg = cfg or Config()

    def process(self, task: Task) -> dict:
        print(f"\n🚀 {task.type.value} | {task.title}")
        start = time.time()
        if task.type == TaskType.BUG_FIX:
            return self._bug_loop(task, start)
        elif task.type == TaskType.FEATURE:
            return self._feature_loop(task, start)
        elif task.type == TaskType.REVIEW:
            return {"status": "reviewed", "time": time.time()-start}
        elif task.type == TaskType.REFACTOR:
            return self._refactor_loop(task, start)

    def _bug_loop(self, task, start):
        for i in range(self.cfg.max_iter):
            print(f"  🔄 迭代{i+1}")
            if self._tests_pass():
                return {"status":"success","iter":i+1,"time":time.time()-start}
        return {"status":"failed","time":time.time()-start}

    def _feature_loop(self, task, start):
        subs = [s for s in re.split(r'[。；]', task.desc) if len(s.strip())>5]
        print(f"  拆解为{len(subs)}个子任务")
        for s in subs:
            for i in range(self.cfg.max_iter):
                if self._tests_pass(): break
        return {"status":"done","subs":len(subs),"time":time.time()-start}

    def _refactor_loop(self, task, start):
        if not self._tests_pass():
            return {"status":"blocked","reason":"测试已失败"}
        for i in range(self.cfg.max_iter):
            if self._tests_pass():
                return {"status":"success","iter":i+1,"time":time.time()-start}
        return {"status":"regression","time":time.time()-start}

    def _tests_pass(self) -> bool:
        try:
            r = subprocess.run(self.cfg.test_cmd.split(), cwd=self.root,
                capture_output=True, text=True, timeout=300)
            return r.returncode == 0
        except: return False

if __name__ == "__main__":
    o = Orchestrator("/path/to/project")
    print(json.dumps(o.process(Task(TaskType.BUG_FIX, "修复邮箱Bug", "大小写问题",
        ["users/service.py"])), ensure_ascii=False, indent=2))
​

常见问题FAQ

Q1: Bug修复循环一直不收敛怎么办？
A: 设置max_iterations硬限制（建议5-8次），超过自动升级。每次迭代更换分析策略（关键词搜索→堆栈追踪→最近变更→关联测试），避免重复相同路径。细化验证条件，加入覆盖率和Lint多维检查。

Q2: 功能开发如何拆解复杂需求？
A: 分层拆解：架构级（新模块/接口）→文件级（创建/修改文件）→函数级（核心+辅助函数）→测试级（对应测试用例）。特别复杂的功能使用Sub-agents分配给不同Agent实例。

Q3: 代码审查如何减少误报？
A: 规则白名单排除已知安全模式、上下文感知分析（不只看单行）、严重度分级（LOW不应阻塞合并）、反馈学习（人类标记误报后调整权重）。

最佳实践与避坑

✅ 验证器优先设计 — 没有可靠验证就无法自动终止循环
✅ Maker-Checker分离 — 编码Agent和审查Agent分开，避免自审自批
✅ Worktree隔离 — 每个循环用独立worktree，避免分支污染
✅ 渐进式自动化 — 从简单确定场景开始，逐步扩展
✅ 结构化日志 — 记录每次迭代的完整决策路径

⚠️ 不要无限循环 — 必须设max_iterations上限
⚠️ 不要跳过验证 — VERIFY阶段是循环存在的意义
⚠️ 不要一次改太多 — 大范围修改引入难以追踪的副作用
⚠️ 不要忽略副作用 — 关注整体测试而非单文件测试
⚠️ 安全代码必须人工审查 — AI修改安全相关代码需人类确认

本节小结

本节实现了软件开发四大循环的完整框架。核心要点：

• Bug修复循环最成熟：discover定位→plan方案→execute修改→verify测试，失败则循环
• 功能开发循环通过需求拆解将复杂任务变为可循环的小任务
• 代码审查循环用规则引擎自动检测安全/逻辑/风格问题并评分决策
• 重构循环以测试不退化为硬约束，小步迭代保证安全

验证器是循环的基石，Maker-Checker分离和Worktree隔离是工程化关键。

下一节过渡

开发循环保证了代码的正确产出，但质量保障不仅靠开发阶段。下一节探讨自主QA与测试循环，学习如何让Agent自主生成测试、分析失败、自愈修复，构建真正的自愈测试系统。

延伸阅读

1. Claude Code文档 — /goal、/loop、worktree详细用法
2. Shiplight AI — Agent-Native QA前沿实践
3. Martin Fowler《重构》— 重构经典原则
4. Google Engineering Practices — 代码审查自动化策略

关键词： Loop Engineering、循环工程、Bug修复自动化、AI代码审查、Claude Code、/goal模式、软件开发循环、Agent驱动开发、代码重构自动化
难度： ⭐⭐⭐ 中级
预计阅读时间： 18分钟