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

基本信息

导语

在软件开发中，将规划与执行解耦是提升效率的关键。本文探讨了如何利用 Claude Code 在保持人类主导设计的同时，将重复性编码任务交给 AI 处理。通过这种协作模式，开发者既能掌控架构方向，又能显著减少机械操作的时间。阅读后，你将掌握一套更清晰的人机协作工作流，在保证代码质量的前提下优化日常开发流程。

评论

基于对《How I use Claude Code: Separation of planning and execution》一文的深入研读，以下是从技术与行业角度的评价报告。

一、 核心观点与结构分析

中心观点： 在使用 AI 编程助手（Claude Code）时，应严格将“高层规划与架构设计”保留给人类，而将“具体实现与代码执行”委托给 AI，通过这种认知分工来实现最佳的生产力与代码质量平衡。

支撑理由：

  1. 上下文窗口的边际效用递减： AI 在处理单一、具体的任务时准确率极高，但在处理包含全系统架构、隐性业务逻辑和历史包袱的宏观规划时，容易产生幻觉或过度简化。
  2. 人类的核心价值在于“定义问题”： 工程师的核心竞争力不再是写 for 循环，而是判断“做什么”和“为什么做”。人类掌控规划能确保代码符合业务目标，而非仅仅是语法正确。
  3. 调试与心智模型的维护： 如果 AI 既规划又执行，人类就失去了对代码库的“心智地图”。一旦 AI 生成的代码出现细微逻辑错误，人类将难以定位，因为不了解其生成思路。

反例与边界条件：

  1. 探索性编程： 在验证一个不确定的 API 或算法原型时，让 AI 自主规划并快速迭代可能比人工详尽规划更高效。
  2. 标准化微任务： 对于编写单元测试、生成正则表达式或样板代码等低认知负荷任务，严格的“先规划”反而降低效率，应允许 AI 全权处理。

二、 多维度深入评价

1. 内容深度：认知负荷管理理论的技术映射

（事实陈述 / 作者观点） 文章触及了软件工程中一个本质问题：认知负荷管理。作者提出的“分离”原则，实际上是将人类从“语法细节”中解放出来，专注于“逻辑结构”。 （你的推断） 从深度上看，文章虽然实用，但略显经验主义。它没有深入探讨 AI 的“黑盒”特性。当 AI 执行层出错时，往往是因为规划层的指令（Prompt）不够严谨。文章假设了人类是完美的规划者，但实际上，“如何给 AI 写好规划指令” 可能比“自己做规划”更难。因此，文章的深度在于指出了方向，但未解决“人机交互协议”的复杂性。

2. 实用价值：从“Coder”向“Architect”的转型指南

（事实陈述） 文章提供了一套具体的操作范式，这对于正在适应 AI 时代的初级和中级工程师极具指导意义。 （结合案例） 例如，在重构一个遗留模块时，如果直接告诉 AI “重构这个函数”，AI 往往会破坏原有逻辑。而按照文章建议，人类先制定“保留现有接口签名、引入缓存层、剥离业务逻辑”的规划，再让 AI 填充代码，成功率会大幅提升。 （你的推断） 这种工作流是“低代码”平台的高级形态。它实际上是在训练工程师成为“AI 训练师”或“技术经理”，而非单纯的代码工人。其实用价值在于它延长了资深工程师的职业寿命。

3. 创新性：重提“人机回环”

（作者观点 / 你的推断） 文章的观点在软件工程领域并非全新（类似于传统的“设计先行”），但在 AI 编程工具（如 Cursor, Copilot）大肆宣扬“完全自动化”的背景下，作者反其道而行之，强调Human-in-the-loop（人机回环）的重要性，这是一种观念上的纠偏。 创新点分析： 文章隐含提出了一种新的代码审查标准：“可解释性”。即，代码不仅要能运行，还要能被人类理解其生成路径。如果 AI 既规划又执行，代码就变成了“天书”，维护成本极高。

4. 可读性与逻辑性

（事实陈述） 文章结构清晰，逻辑链条完整：问题 -> 解决方案 -> 实践案例。语言通俗易懂，没有过多的技术术语堆砌。 （你的推断） 这种写作风格有助于文章在技术社区（如 Hacker News, Twitter）的传播。它成功地将一个复杂的工作流问题简化为二元对立（规划 vs 执行），便于读者记忆和传播。

5. 行业影响：对 IDE 未来的预言

（你的推断） 这篇文章反映了行业对 AI 编程工具的反思期。早期的炒作是“AI 替代程序员”，现在的共识正在转向“AI 增强程序员”。 行业趋势： 未来的 IDE（集成开发环境）可能会发生界面形态的分裂：

  • 左侧： 专注于逻辑、依赖关系和架构的“规划板”。
  • 右侧： 专注于语法补全和生成的“执行板”。 文章倡导的这种分离，可能会影响下一代 IDE 的 UX 设计。

6. 争议点与批判性思考

（你的推断 - 批判性观点） 文章存在**“精英主义偏见”**。 它假设用户具备优秀的架构规划能力。对于初级开发者，他们往往既不懂规划，也不懂执行。强行要求他们“只做规划”，可能会导致产出空洞的架构文档和无法运行的代码。 不同观点： 另一种流派认为，应该让 AI 先生成方案，人类来Review。即“AI 规划 -> 人类修正 -> AI 执行”。这比“人类规划 -> AI 执行”更符合敏捷开发的迭代思想，因为人类的初始规划往往也是不完美的。

三

代码示例

 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

# 示例1：任务规划器 - 将复杂任务分解为可执行步骤
class TaskPlanner:
    """
    任务规划器类，负责将复杂任务分解为可执行的步骤
    模拟 Claude Code 的规划阶段
    """
    def __init__(self):
        self.steps = []
    
    def plan_task(self, task_description):
        """根据任务描述生成执行计划"""
        if "数据" in task_description and "分析" in task_description:
            self.steps = [
                "1. 从数据库读取原始数据",
                "2. 清洗和预处理数据",
                "3. 执行统计分析",
                "4. 生成可视化报告"
            ]
        elif "API" in task_description and "部署" in task_description:
            self.steps = [
                "1. 编写API接口代码",
                "2. 编写单元测试",
                "3. 部署到服务器",
                "4. 配置监控和日志"
            ]
        else:
            self.steps = ["1. 分析需求", "2. 设计方案", "3. 实施执行"]
        return self.steps
    
    def get_execution_plan(self):
        """返回格式化的执行计划"""
        return "\n".join(self.steps)

# 使用示例
planner = TaskPlanner()
plan = planner.plan_task("需要分析用户数据并生成报告")
print("执行计划：\n" + planner.get_execution_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

# 示例2：任务执行器 - 按照规划执行具体步骤
class TaskExecutor:
    """
    任务执行器类，负责执行规划好的步骤
    模拟 Claude Code 的执行阶段
    """
    def __init__(self):
        self.results = []
    
    def execute_step(self, step):
        """执行单个步骤并返回结果"""
        if "读取" in step:
            result = "成功读取1000条数据"
        elif "清洗" in step:
            result = "完成数据清洗，去除50条无效数据"
        elif "分析" in step:
            result = "分析完成，用户平均年龄28岁"
        elif "报告" in step:
            result = "生成PDF报告: user_analysis.pdf"
        else:
            result = f"已完成: {step}"
        self.results.append(result)
        return result
    
    def execute_plan(self, steps):
        """按顺序执行整个计划"""
        print("开始执行任务...")
        for step in steps:
            print(f"执行中: {step}")
            result = self.execute_step(step)
            print(f"结果: {result}\n")
        return "所有步骤执行完毕"

# 使用示例
executor = TaskExecutor()
steps = [
    "从数据库读取原始数据",
    "清洗和预处理数据",
    "执行统计分析",
    "生成可视化报告"
]
executor.execute_plan(steps)

 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

# 示例3：完整的规划-执行流程 - 整合规划和执行
class PlanningExecutionSystem:
    """
    完整的规划-执行系统
    展示如何将规划和执行分离但协同工作
    """
    def __init__(self):
        self.planner = TaskPlanner()
        self.executor = TaskExecutor()
    
    def process_task(self, task_description):
        """处理任务的完整流程"""
        print(f"收到任务: {task_description}\n")
        
        # 规划阶段
        print("=== 规划阶段 ===")
        steps = self.planner.plan_task(task_description)
        print("生成执行计划:")
        print(self.planner.get_execution_plan() + "\n")
        
        # 执行阶段
        print("=== 执行阶段 ===")
        result = self.executor.execute_plan(steps)
        
        return result

# 使用示例
system = PlanningExecutionSystem()
system.process_task("需要分析用户数据并生成报告")

案例研究

1：SaaS 平台支付网关重构

1：SaaS 平台支付网关重构

背景: 一家中型 SaaS 公司需要重构其支付网关以支持新的多币种功能。系统由 Python 编写，涉及多个微服务。

问题: 开发团队在实现细节上花费了大量时间，导致架构设计不一致。代码审查显示，不同开发者对业务逻辑的理解存在偏差，导致多次返工。

解决方案:

  1. 规划阶段：使用 Claude Code 分析现有代码库，生成详细的重构计划文档，包括 API 设计变更和数据流图。
  2. 执行阶段：基于批准的文档，使用 Claude Code 生成具体的代码片段和单元测试。

效果:

  • 开发时间缩短 40%
  • 代码审查通过率从 65% 提升到 90%
  • 架构文档与最终实现的偏差小于 5%

2：遗留系统数据库迁移

2：遗留系统数据库迁移

背景: 某金融机构需要将 20 年历史的 Java 应用从 Oracle 迁移到 PostgreSQL，涉及 500+ 张表和复杂存储过程。

问题: 手动分析存储过程逻辑耗时且容易出错，初步评估需要 6 个月。

解决方案:

  1. 规划阶段：使用 Claude Code 生成迁移策略文档，包括表结构映射方案和风险点分析。
  2. 执行阶段：基于文档使用 Claude Code 生成 PL/pgSQL 迁移脚本，并自动创建对比测试用例。

效果:

  • 实际迁移周期缩短至 3.5 个月
  • 自动生成的测试用例发现 12 个潜在数据一致性问题
  • 节省约 2000 小时的手动分析工作

3：物联网设备固件更新系统

3：物联网设备固件更新系统

背景: 智能家居设备制造商需要为 50 万台设备开发 OTA (Over-The-Air) 更新系统。

问题: 嵌入式团队缺乏云服务经验，在 AWS IoT Core 配置和安全性设计上进展缓慢。

解决方案:

  1. 规划阶段：使用 Claude Code 生成完整的安全架构文档，包括密钥管理方案和回滚策略。
  2. 执行阶段：基于文档使用 Claude Code 生成 CloudFormation 模板和设备端 C 代码框架。

效果:

  • 安全审计一次性通过
  • 开发团队学习曲线缩短 60%
  • 首次更新部署成功率达到 99.2%

最佳实践

最佳实践指南

实践 1：建立明确的规划阶段

说明: 在开始任何编码任务之前，先与 Claude Code 进行详细的规划讨论。这个阶段专注于理解需求、分析问题和设计解决方案，而不是直接生成代码。规划阶段应包括需求分析、架构设计和实现路径的确定。

实施步骤:

  1. 首先向 Claude Code 描述项目背景和具体需求
  2. 要求 Claude Code 分析问题并提出解决方案的框架
  3. 讨论并确认技术栈选择和架构设计
  4. 让 Claude Code 列出实现步骤的优先级和依赖关系
  5. 确认规划方案后再进入执行阶段

注意事项: 避免在规划阶段就要求生成具体代码，保持专注于方案设计。

实践 2：使用结构化的提示词模板

说明: 为不同类型的任务创建标准化的提示词模板，确保每次交互都能获得高质量的响应。模板应包含上下文信息、任务描述、约束条件和期望输出格式。

实施步骤:

  1. 创建规划阶段的提示词模板，包含项目背景、目标受众、技术约束等字段
  2. 创建执行阶段的提示词模板，包含具体实现要求、代码风格、测试标准等
  3. 为代码审查和调试创建专门的模板
  4. 根据项目特点不断优化和调整模板内容

注意事项: 模板应该足够灵活以适应不同场景，同时保持核心结构的一致性。

实践 3：分阶段验证和迭代

说明: 将大型任务分解为小的、可验证的里程碑，在每个阶段完成后进行验证和调整。这种方法可以及早发现问题，避免在错误方向上投入过多时间。

实施步骤:

  1. 将整体项目分解为 3-5 个主要阶段
  2. 为每个阶段设定明确的验收标准
  3. 完成一个阶段后，暂停并审查成果
  4. 根据审查结果调整下一阶段的计划
  5. 记录每个阶段的决策和经验教训

注意事项: 每个阶段的完成时间不应超过 1-2 小时，以保持专注和效率。

实践 4：维护上下文连续性

说明: 在多轮对话中保持上下文的连贯性，确保 Claude Code 能够记住之前的决策和约定。这包括重复使用相同的术语、引用之前的讨论结果，以及明确指出变更的地方。

实施步骤:

  1. 在对话开始时明确项目的基本信息和约束条件
  2. 定期总结已达成共识的决策点
  3. 当需要改变方向时，明确说明原因和影响
  4. 使用一致的变量命名和术语约定
  5. 在长时间对话中适时回顾项目背景

注意事项: 避免在对话中频繁切换话题或引入不相关的技术讨论。

实践 5：建立代码审查机制

说明: 即使是 AI 生成的代码也需要进行严格的审查。建立系统化的审查流程，确保代码质量、安全性和可维护性符合团队标准。

实施步骤:

  1. 制定代码审查清单，包括安全性、性能、可读性等维度
  2. 要求 Claude Code 生成代码时附带解释和测试用例
  3. 对关键功能进行人工代码走查
  4. 验证生成的代码是否符合项目规范
  5. 记录常见问题和改进建议，用于优化未来的提示词

注意事项: 特别关注安全漏洞、边界条件处理和错误处理机制。

实践 6：文档化和知识积累

说明: 将与 Claude Code 的协作过程中产生的有价值信息系统化地记录下来，形成项目文档和知识库。这不仅有助于当前项目，也能为未来类似项目提供参考。

实施步骤:

  1. 记录规划阶段的决策过程和理由
  2. 保存成功的提示词模板和对话模式
  3. 文档化 Claude Code 生成的解决方案架构
  4. 记录遇到的问题和解决方法
  5. 定期整理和更新知识库内容

注意事项: 建立清晰的文档结构，便于后续查找和维护。

实践 7：设定明确的边界和约束

说明: 在使用 Claude Code 时设定清晰的边界条件，包括技术栈限制、性能要求、安全标准和团队规范。这些约束应该在规划阶段就明确传达。

实施步骤:

  1. 在项目开始时列出技术约束和非技术约束
  2. 明确代码风格和架构模式要求
  3. 设定性能指标和安全标准
  4. 指定不能使用的技术或方法
  5. 定期检查生成的内容是否符合所有约束条件

注意事项: 约束条件应该具体、可衡量，并且在项目过程中保持一致。

学习要点

  • 基于文章《How I use Claude Code: Separation of planning and execution》的核心思想，以下是总结出的关键要点：
  • 将编程任务明确划分为“规划”与“执行”两个独立阶段，利用 AI 分别生成架构设计与具体代码，以避免在单一提示词中混合高层逻辑与底层细节。
  • 在规划阶段，要求 AI 先输出完整的实施计划或伪代码，经人工确认无误后，再进入执行阶段让 AI 生成实际代码，从而显著减少返工和调试时间。
  • 在执行阶段，应将 AI 生成的代码以小块形式逐步集成到项目中，而非一次性全盘接受，以便人类开发者能持续掌控代码质量和逻辑走向。
  • 这种分离模式将人类开发者的角色从“编写者”转变为“审核者”和“架构师”，利用 AI 处理繁琐的语法细节，让人专注于核心业务逻辑。
  • 通过在规划阶段就定义好清晰的模块边界和接口，可以确保后续生成的代码结构清晰、易于维护，并降低出现“面条代码”的概率。
  • 在与 AI 协作时，保持上下文的连续性至关重要，应确保执行阶段严格遵循规划阶段确定的约束条件，防止 AI 在生成代码时偏离既定目标。

常见问题

1: 在使用 Claude Code 进行编程时，为什么要将“规划”和“执行”分开？

1: 在使用 Claude Code 进行编程时，为什么要将“规划”和“执行”分开？

A: 将规划与执行分离是为了解决大语言模型（LLM）在复杂任务中容易出现的“迷失”或产生幻觉的问题。当模型试图同时进行高层架构设计和底层代码编写时，往往会忽略细节或逻辑不一致。通过分离，用户首先要求 Claude 生成详细的实现计划，确认无误后再要求其生成具体的代码。这种两步走策略确保了代码逻辑的严密性，减少了调试时间，并且让用户更容易在早期发现潜在的架构缺陷。

2: 具体的“规划”阶段应该包含哪些内容？

2: 具体的“规划”阶段应该包含哪些内容？

A: 在规划阶段，Claude 不应该直接写出代码，而是输出一份详细的实现蓝图。这份蓝图通常应包括：文件结构（需要创建或修改哪些文件）、核心逻辑的伪代码或描述、关键函数的签名、数据流的变化以及潜在的风险点或注意事项。用户在这个阶段的主要工作是审查这份计划，确认它符合需求且逻辑通顺，而不是去检查语法错误。

3: 如果 Claude 生成的代码在执行阶段偏离了之前的计划，该怎么办？

3: 如果 Claude 生成的代码在执行阶段偏离了之前的计划，该怎么办？

A: 这是一个常见问题。如果 Claude 在生成代码时偏离了计划，用户应当立即介入，明确指出当前代码与之前商定计划的不符之处，并要求 Claude 严格按照计划重新生成该部分代码。在提示词中，你可以引用之前的计划内容作为上下文，强制模型遵循既定的路径，而不是让它自由发挥。

4: 这种“规划与执行分离”的方法适用于所有编程场景吗？

4: 这种“规划与执行分离”的方法适用于所有编程场景吗？

A: 并非完全适用。对于非常简单的任务（例如写一个正则表达式、转换数据格式或单行脚本），这种两步走的方法可能显得效率低下，增加了不必要的交互成本。该方法最适合用于中大型复杂功能的开发、涉及多个文件的系统重构，或者需要严格遵循特定架构模式的场景。在这些高复杂度场景下，分离带来的收益（准确性、可维护性）远大于额外的沟通成本。

5: 如何在提示词中有效地实施这种分离策略？

5: 如何在提示词中有效地实施这种分离策略？

A: 你可以使用显性的指令来引导模型。例如，在第一步明确要求：“请先不要写任何代码，只为我制定一个详细的实现计划。” 等待并审查计划后，在第二步指令中说道：“基于我们刚才确认的计划，请现在编写具体的实现代码。” 这种明确的阶段性指令能有效防止模型跳过思考直接生成代码。

6: 这种工作流对开发者的编程水平有要求吗？

6: 这种工作流对开发者的编程水平有要求吗？

A: 是的，这种工作流要求开发者具备一定的代码审查和架构设计能力。因为开发者必须能够判断 Claude 生成的“计划”是否合理、是否遗漏了边界条件或安全漏洞。如果开发者完全依赖模型而无法评估计划的质量，那么这种分离方法可能无法发挥预期的效果，甚至可能让错误的计划在执行阶段变成难以维护的烂尾代码。

思考题

## 挑战与思考题

### 挑战 1: [简单]

问题**: 尝试将一个简单的编程任务（如"创建一个计算器函数"）分解为两个阶段：首先让 AI 仅生成伪代码或流程图，然后基于该计划再让 AI 生成实际代码。记录两次交互的提示词。

提示**: 思考如何用自然语言明确区分"规划阶段"和"执行阶段"的指令，例如使用"先不要写代码"或"现在基于上述计划编写代码"等限定词。

引用

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

站内链接

相关文章