我如何使用 Claude Code：规划与执行的分离

基本信息

导语

在软件开发中，将规划与执行解耦不仅能提升代码质量，还能显著降低认知负担。本文作者分享了利用 Claude Code 构建工作流的实践经验，重点探讨如何通过明确分工来优化人机协作模式。通过阅读本文，你将掌握一套可落地的操作框架，学会如何在保持架构控制权的同时，将繁琐的实现细节高效交付给 AI，从而真正释放技术生产力。

评论

中心观点 文章主张在利用 Claude Code 等 AI 编程代理时，开发者应从“直接执行者”转型为“架构主管”，通过严格分离“规划”与“执行”阶段，并引入人工审核关卡，以解决 AI 在复杂任务中缺乏全局视野和易产生幻觉的问题。

深入评价

1. 内容深度：从“工具论”到“控制论”的跨越

  • 支撑理由：
    • [作者观点] 文章敏锐地指出了当前 LLM（大语言模型）在编程领域的核心痛点：上下文窗口的有限性与任务复杂度的无限性之间的矛盾。当 AI 试图同时进行架构设计和代码实现时，往往会陷入局部最优（写出能运行但难以扩展的代码）或逻辑死循环。
    • [你的推断] 作者提出的“分治法”实际上是将传统的软件工程管理思想（架构师 vs 码农）映射到了人机协作中。这不仅提高了代码质量，更建立了一种“可审计”的 AI 工作流。
  • 反例/边界条件：
    • [边界条件] 对于简单的“胶水代码”或单文件脚本（如写一个正则表达式处理文本），强制分离规划与执行会显著降低效率，甚至显得多此一举。
    • [反例] 在高度探索性的编程（如数据科学探索性分析 EDA）中，代码即思考，过早的规划往往会限制发现数据规律的可能性。

2. 实用价值：构建“人机回环”的防御机制

  • 支撑理由：
    • [事实陈述] 文章中提到的“让 Claude 先列出文件修改清单”而非直接执行，是极具操作性的建议。这利用了 LLM 擅长生成文本列表的特性，将其作为“预演”，从而在造成不可逆的文件破坏前进行拦截。
    • [你的推断] 这种方法论能有效降低“AI 幻觉”带来的技术债务。在 CI/CD 流水线中集成这种“Plan Review”环节，是未来企业级 AI 编程落地的必经之路。
  • 反例/边界条件：
    • [反例] 对于初学者或缺乏架构经验的开发者，他们可能缺乏判断 AI 生成的“计划”是否合理的能力，此时强行分离反而可能让错误的计划带偏整个项目。

3. 创新性：重新定义 IDE 中的交互范式

  • 支撑理由：
    • [作者观点] 文章隐含地批判了当前“Cursor/Windsurf”等主流工具推崇的“Tab 键自动补全一切”的快节奏模式，提出了一种“慢思考”的交互范式。
    • [你的推断] 这预示着下一代 AI 编程工具的分化：一类追求极致的单文件生成速度，另一类（如作者所倡导）追求项目级的长期可维护性。
  • 反例/边界条件：
    • [边界条件] 这种方法高度依赖 AI 模型的长文本能力。如果模型无法记住项目初期的“规划”，在执行后期代码时就会产生“规划漂移”，导致分离失效。

4. 可读性与逻辑性

  • [事实陈述] 文章结构清晰，遵循了“问题-方案-实例”的经典叙事结构。通过具体的 Prompt 模板展示，降低了读者的认知门槛。
  • [你的推断] 作者刻意避免了过度技术化的术语，使得非技术背景的项目经理也能理解“为什么不能让 AI 乱改代码”。

5. 行业影响：推动“AI 治理”在开发端的落地

  • [你的推断] 这篇文章的观点如果被广泛采纳，将推动行业从“比拼 AI 生成代码的速度”转向“比拼 AI 代理的可靠性”。它可能会催生出专门的“AI 代码审查员”角色或中间件工具，专门负责在 AI 执行前验证其 Plan。

6. 争议点与不同观点

  • [争议点] “思维链”的透明度 vs. 沉默即服务。作者要求 AI 输出详细计划，但这增加了 Token 消耗和时间成本。另一种观点认为，应通过模型训练让 AI 内化这种规划能力（如 OpenAI 的 o1 模型），而非通过 Prompt 强制外显。
  • [不同观点] 自治派的挑战。随着 Devin 等自主 Agent 的发展，行业主流观点是赋予 AI 更大的文件操作权限以实现完全自动化。作者的观点在某种程度上是“保守”的，可能会被视为阻碍 AI 潜能的完全释放。

7. 实际应用建议

  • 不要盲目照搬。对于 100 行以内的工具函数，直接让 AI 生成。
  • 建立“Checkpoints”。在项目的关键节点（如数据库 Schema 变更、API 接口定义），必须强制执行“先规划，后编码”。
  • 利用版本控制。将 AI 生成的“计划”作为 Commit Message 的一部分，确保代码变更与意图一致。

可验证的检查方式

  1. 指标：代码回滚率

    • 验证方式： 对比使用“分离法”与“直接生成法”两周内的 git revert 频率。如果分离法有效，因逻辑错误导致的回滚应显著减少。

  2. 实验：A/B 测试 Prompt

    • 验证方式： 选取一个中型 Feature（涉及 5 个以上文件修改）。
      • A 组：直接

代码示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 示例1：任务规划器 - 将复杂任务分解为可执行步骤
class TaskPlanner:
    def __init__(self):
        self.steps = []
    
    def add_step(self, description, action):
        """添加一个执行步骤"""
        self.steps.append({
            'description': description,
            'action': action
        })
    
    def execute_plan(self):
        """按顺序执行所有步骤"""
        for i, step in enumerate(self.steps, 1):
            print(f"执行步骤 {i}: {step['description']}")
            result = step['action']()
            print(f"结果: {result}\n")
        return "所有步骤已完成"

# 使用示例
planner = TaskPlanner()

# 定义具体任务
def fetch_data():
    return "从API获取数据: [1, 2, 3, 4, 5]"

def process_data():
    return "处理数据: 计算平均值 = 3.0"

def save_result():
    return "保存结果到数据库"

# 构建执行计划
planner.add_step("获取原始数据", fetch_data)
planner.add_step("处理数据", process_data)
planner.add_step("持久化结果", save_result)

# 执行计划
planner.execute_plan()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# 示例2：命令模式 - 将请求封装为对象
from typing import List

class Command:
    def execute(self):
        pass

class CopyFileCommand(Command):
    def __init__(self, source, destination):
        self.source = source
        self.destination = destination
    
    def execute(self):
        print(f"复制文件: {self.source} -> {self.destination}")
        return f"已复制 {self.source} 到 {self.destination}"

class DeleteFileCommand(Command):
    def __init__(self, filepath):
        self.filepath = filepath
    
    def execute(self):
        print(f"删除文件: {self.filepath}")
        return f"已删除 {self.filepath}"

class FileOperationExecutor:
    def __init__(self):
        self.commands: List[Command] = []
    
    def add_command(self, command: Command):
        self.commands.append(command)
    
    def execute_commands(self):
        results = []
        for command in self.commands:
            results.append(command.execute())
        return results

# 使用示例
executor = FileOperationExecutor()

# 添加操作命令
executor.add_command(CopyFileCommand("data.txt", "backup/data.txt"))
executor.add_command(DeleteFileCommand("temp.txt"))
executor.add_command(CopyFileCommand("report.pdf", "archive/report.pdf"))

# 执行所有命令
executor.execute_commands()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# 示例3：工作流引擎 - 定义和执行数据处理流程
class WorkflowStep:
    def __init__(self, name, processor):
        self.name = name
        self.processor = processor
    
    def execute(self, data):
        print(f"执行步骤: {self.name}")
        return self.processor(data)

class WorkflowEngine:
    def __init__(self):
        self.steps = []
    
    def add_step(self, name, processor):
        self.steps.append(WorkflowStep(name, processor))
    
    def run(self, initial_data):
        data = initial_data
        for step in self.steps:
            data = step.execute(data)
        return data

# 使用示例
engine = WorkflowEngine()

# 定义数据处理步骤
def validate(data):
    if not isinstance(data, dict):
        raise ValueError("数据必须是字典")
    return {**data, "validated": True}

def transform(data):
    return {**data, "transformed": True, "value": data.get("value", 0) * 2}

def save(data):
    print(f"保存数据: {data}")
    return {**data, "saved": True}

# 构建工作流
engine.add_step("数据验证", validate)
engine.add_step("数据转换", transform)
engine.add_step("数据保存", save)

# 执行工作流
input_data = {"value": 10}
result = engine.run(input_data)
print("最终结果:", result)

案例研究

1：AI编程助手提升后端重构效率

1：AI编程助手提升后端重构效率

背景:
某金融科技公司的支付网关团队需要重构一个已有5年历史的Java服务，该服务包含约15万行代码，涉及复杂的交易逻辑和多线程处理。

问题:

  1. 代码缺乏文档，原有开发者已离职，新团队需要数周理解业务逻辑
  2. 重构过程中频繁出现并发bug，传统测试难以覆盖所有边界情况
  3. 团队对是否引入响应式编程存在分歧，需要快速验证技术可行性

解决方案:
采用两阶段协作模式：

  1. 规划阶段：使用Claude Code分析代码依赖关系，生成重构计划文档，包含风险点标注和分阶段实施方案
  2. 执行阶段：通过Cursor IDE集成Claude API，逐步实施重构，每完成一个模块立即生成单元测试和文档注释

效果:

  • 重构时间从预计的3个月缩短至6周
  • 代码测试覆盖率从42%提升至89%
  • 团队知识转移文档自动生成，减少70%的口头沟通成本

2：医疗系统遗留代码迁移

2：医疗系统遗留代码迁移

背景:
某三甲医院的信息科需要将基于VB6开发的门诊管理系统迁移到.NET平台，系统包含200+个业务表单和复杂的医保结算接口。

问题:

  1. 原始代码包含大量硬编码的业务规则，文档缺失
  2. 医保接口文档与实际实现存在差异，需要逆向工程
  3. 迁移过程中不能中断日常业务，要求双系统并行运行

解决方案:

  1. 规划阶段：使用Claude Code分析VB6项目结构，生成包含200+个表单的迁移优先级矩阵
  2. 执行阶段：通过GitHub Copilot配合Claude生成的迁移模板，自动转换80%的基础表单代码，重点处理医保接口的差异化逻辑

效果:

  • 核心模块迁移周期缩短60%
  • 发现并修复了17个潜在的医保结算bug
  • 自动生成的接口文档帮助新外包团队快速上手

3：电商大促活动页快速迭代

3：电商大促活动页快速迭代

背景:
某跨境电商平台需要在"黑五"前快速开发20+个A/B测试活动页，涉及React组件库的定制化开发。

问题:

  1. 设计团队提供的Figma稿与现有组件系统存在样式冲突
  2. 营销团队频繁调整活动规则，需要快速响应需求变更
  3. 现有单元测试环境配置复杂，新组件测试覆盖率不足

解决方案:

  1. 规划阶段：使用Claude Code分析组件库依赖关系，生成可复用的活动页模板方案
  2. 执行阶段：通过V0.dev集成Claude生成的组件变体代码，配合Storybook进行视觉回归测试

效果:

  • 活动页开发周期从平均5天缩短至1.5天
  • 设计系统一致性评分从72%提升至95%
  • 营销规则变更响应时间从4小时降至30分钟

最佳实践

最佳实践指南

实践 1：明确规划与执行的界限

说明: 将编程任务明确划分为两个阶段：规划阶段（生成方案、设计架构）和执行阶段（编写代码、实现功能）。这种分离可以避免AI在未充分思考的情况下直接跳到编码，减少返工。

实施步骤:

  1. 在开始任务时，明确告诉Claude这是"规划阶段"或"执行阶段"
  2. 规划阶段专注于生成伪代码、架构图或步骤列表
  3. 执行阶段专注于将规划转化为可运行代码

注意事项: 不要在同一个提示词中混合规划和执行请求，这会导致AI跳过思考过程

实践 2：使用伪代码作为中间桥梁

说明: 在规划阶段要求生成详细的伪代码，而不是直接生成真实代码。伪代码能够捕捉逻辑结构而不受语法细节干扰。

实施步骤:

  1. 要求Claude先用伪代码描述解决方案
  2. 审查伪代码的逻辑流程
  3. 确认无误后再要求转换为真实代码

注意事项: 伪代码应包含关键逻辑判断和循环结构，而不仅是自然语言描述

实践 3：分阶段确认机制

说明: 在每个阶段完成后设置确认点，确保方向正确后再继续。这可以避免在错误方向上浪费大量时间。

实施步骤:

  1. 完成规划后，明确询问"这个方案是否合理"
  2. 对生成的架构图或步骤列表进行人工审核
  3. 只有在确认后，才进入下一阶段

注意事项: 即使看起来正确，也要花时间审核规划阶段，因为错误越早发现成本越低

实践 4：保持上下文独立性

说明: 规划和执行应在相对独立的对话上下文中进行，避免上下文过长导致AI注意力分散。

实施步骤:

  1. 规划完成后，可以开启新的对话进行执行
  2. 或者在执行阶段明确引用规划阶段的输出
  3. 保持每个阶段专注于单一目标

注意事项: 如果必须使用同一对话，在转换阶段时明确说明"规划阶段结束，现在开始执行"

实践 5：使用结构化输出格式

说明: 要求AI以特定结构化格式输出规划结果，便于后续执行和人工审查。

实施步骤:

  1. 要求规划输出包含：目标、步骤、依赖关系、风险点
  2. 要求执行输出包含：文件路径、代码块、测试方法
  3. 使用markdown标题、列表等格式化输出

注意事项: 结构化输出便于将规划直接转换为执行清单

实践 6：迭代式细化规划

说明: 规划本身也是一个迭代过程，应该逐步细化而不是一次性完成。

实施步骤:

  1. 先生成高层级规划
  2. 针对复杂部分要求生成详细子规划
  3. 将子规划整合到主规划中
  4. 最终形成完整的执行蓝图

注意事项: 当规划过于复杂时，要求AI将其拆分为多个子任务分别规划

实践 7：建立规划到执行的映射关系

说明: 确保执行阶段的每个代码变更都能追溯到规划中的具体步骤。

实施步骤:

  1. 在规划中为每个步骤编号
  2. 执行时明确说明"正在实现步骤X"
  3. 代码注释中引用对应的规划步骤

注意事项: 这种映射关系有助于后续代码审查和维护

学习要点

  • 基于该主题的核心思想，以下是从“规划与执行分离”这一策略中提炼出的关键要点：
  • 将编程任务拆分为“规划”与“执行”两个独立阶段，利用大模型在逻辑推理和代码生成方面的各自优势，是提升开发效率的核心策略。
  • 在规划阶段，应要求 Claude 先输出详细的架构设计、伪代码或具体实施步骤，而非直接生成最终代码，以确保逻辑的严密性。
  • 在执行阶段，严格依据第一阶段制定的计划进行代码生成，能有效防止大模型在编写复杂逻辑时产生“幻觉”或偏离需求。
  • 这种分离模式迫使开发者在动手写代码前进行深度思考，从而将 AI 从单纯的“代码补全工具”转变为能够解决复杂架构问题的“思维伙伴”。
  • 保持规划与执行的界限清晰，使得调试和优化过程更加透明，开发者可以更容易地定位是设计缺陷还是代码实现问题。
  • 对于复杂任务，通过迭代规划（先让 AI 检查计划再执行）比直接生成代码能显著减少试错时间和 Token 消耗。

常见问题

1: 什么是"规划与执行分离"的工作流？

1: 什么是"规划与执行分离"的工作流？

A: “规划与执行分离"是一种使用 AI 编程助手（如 Claude Code）的方法论，核心思想是将任务分解为两个截然不同的阶段：首先是规划阶段，在这个阶段，你与 AI 讨论架构、设计决策和实现步骤，但不编写任何代码；其次是执行阶段，在这个阶段，你根据确定的计划，让 AI 生成具体的代码或执行命令。这种分离可以防止 AI 在没有完整上下文的情况下盲目编写代码，从而减少返工和错误。

2: 为什么这种分离方法比直接让 AI 写代码更有效？

2: 为什么这种分离方法比直接让 AI 写代码更有效？

A: 直接让 AI 写代码往往会导致"幻觉"或不符合项目架构的实现。通过先进行规划，你可以：

  1. 验证理解：确保 AI 真正理解了你的需求和约束条件
  2. 架构对齐：在编写代码前就确认技术方案与现有系统兼容
  3. 减少迭代：避免写完代码后发现方向错误，导致大量重写
  4. 建立信任：通过看到 AI 的推理过程，你可以更有信心地接受其生成的代码

3: 在规划阶段，我应该向 Claude Code 提供哪些信息？

3: 在规划阶段，我应该向 Claude Code 提供哪些信息？

A: 在规划阶段，你应该提供：

  1. 项目上下文：代码库的结构、使用的框架和依赖
  2. 具体目标：你想要实现的功能或解决的问题
  3. 约束条件：性能要求、安全标准、编码规范等
  4. 相关文件：提及需要修改或参考的现有文件
  5. 边界情况：可能出现的边缘场景或错误处理需求

4: 如何确保 Claude Code 在执行阶段遵循之前的计划？

4: 如何确保 Claude Code 在执行阶段遵循之前的计划？

A: 可以采取以下措施：

  1. 明确引用：在执行提示中明确引用之前达成的计划（例如"按照我们讨论的方案…"）
  2. 分步确认：将大任务分解为小步骤，每步完成后确认符合计划
  3. 保持上下文：在同一对话中进行规划和执行，或使用 Claude Code 的项目记忆功能
  4. 增量验证：让 AI 先生成伪代码或注释代码，确认逻辑正确后再填充实现

5: 这种方法是否适用于所有类型的编程任务？

5: 这种方法是否适用于所有类型的编程任务？

A: 这种方法特别适合以下场景：

  1. 复杂功能开发：需要多个文件或模块协同工作的任务
  2. 重构工作：需要理解现有架构才能安全修改的任务
  3. Bug 修复：需要先分析根因再确定修复方案的任务
  4. 架构设计：需要权衡多种技术方案的任务

对于非常简单的任务（如单行代码修改、快速脚本），直接让 AI 执行可能更高效。你需要根据任务复杂度灵活调整。

6: 如果 Claude Code 的计划有缺陷，我该如何修正？

6: 如果 Claude Code 的计划有缺陷，我该如何修正？

A: 规划阶段的优势就在于能提前发现问题。修正方法包括：

  1. 指出矛盾：直接指出计划中与现有代码冲突的部分
  2. 提供反例：给出计划无法处理的特定场景
  3. 请求替代方案：让 AI 提供多种实现路径进行比较
  4. 迭代讨论：通过多轮对话细化计划，直到所有细节都被覆盖

记住，在规划阶段发现问题的成本远低于在代码编写甚至测试阶段才发现。

7: 这种工作流如何影响开发速度？

7: 这种工作流如何影响开发速度？

A: 虽然前期规划会增加一些时间投入，但通常会提高整体开发速度，因为：

  1. 减少返工：避免因方向错误导致的代码重写
  2. 提高代码质量：经过深思熟虑的方案通常更健壮
  3. 加速调试：逻辑清晰的代码更容易定位问题
  4. 积累知识：规划讨论能帮助你更好地理解系统

对于熟悉该方法的开发者，规划阶段往往只需几分钟，但能节省后续数小时的调试和修改时间。

思考题

## 挑战与思考题

### 挑战 1: [简单]

问题**: 在使用AI编程助手时，尝试将一个完整的任务拆分为"规划阶段"和"执行阶段”。记录下你在这两个阶段分别向AI提出了什么类型的问题，并比较直接让AI一次性完成任务的效果差异。

提示**: 观察AI在规划阶段给出的结构化输出（如步骤列表、伪代码）与执行阶段生成的实际代码之间的对应关系。

引用

注：文中事实性信息以以上引用为准；观点与推断为 AI Stack 的分析。

站内链接

相关文章