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

基本信息

导语

在软件开发中，将构思与编码解耦往往能显著提升效率。本文分享了作者利用 Claude Code 实现规划与执行分离的实践经验，探讨了如何通过明确职责边界来优化工作流。阅读本文，你将了解一种更清晰的 AI 辅助编程模式，从而在保持代码质量的同时，更好地掌控开发节奏与逻辑细节。

评论

深度评论：AI 编程中“规划”与“执行”解耦的范式转移

文章中心观点： 在 AI 辅助编程的语境下，开发者应尝试将“逻辑规划”与“代码实现”分离。利用 AI 工具（如 Claude Code）处理具体的语法实现和文件操作，而人类开发者专注于架构设计和业务逻辑的验证。这种分工旨在优化人机协作的效率，而非完全替代人类的思考。

评价与分析：

1. 支撑理由与论证分析

  • 理由一：基于比较优势的分工（作者观点）

    • 分析： 文章的逻辑基础在于“比较优势”。人类通常更擅长处理模糊的业务需求、跨文件的上下文关联以及整体价值的判断；而 AI 擅长处理精确的语法、API 查询和样板代码的编写。将两者结合，试图减少开发者在微观实现上的认知负载。
    • 事实陈述： Claude Code 等工具具备操作文件系统和运行终端的能力，这为“委托执行”提供了技术可行性。

  • 理由二：降低代码审查的复杂度（推断）

    • 分析： 直接让 AI 生成大段代码往往增加审查难度，因为审查者需要重新推导逻辑。如果采用“规划-执行”分离，人类先制定计划，再由 AI 填充代码。审查的重点转变为“代码是否符合预设计划”，这在一定程度上降低了验证逻辑正确性的成本。

  • 理由三：开发角色的转变（行业趋势）

    • 分析： 文章反映了软件工程工作流的一种潜在变化：从“逐行编写”向“审核与组装”倾斜。这要求开发者具备更强的代码审查和系统设计能力，以适应新的工具链。

2. 反例与边界条件

  • 反例一：探索性编程

    • 边界条件： 在项目初期或算法验证阶段，具体的实现路径往往不明确。
    • 分析： 此时强行分离规划与执行可能会打断思路。通过快速编写代码片段进行试错，比先制定详细计划更为高效。

  • 反例二：遗留系统维护

    • 边界条件： 面对文档缺失或逻辑高度耦合的旧代码。
    • 分析： AI 可能难以理解隐含的业务规则。在这种情况下，如果人类不深入细节进行指导，仅凭高层规划很容易导致现有逻辑被破坏。

3. 分维度深度评价

  • 内容深度（7/10）：

    • 文章探讨了 AI 时代编程工作流调整的实际问题。虽然人机分工并非新话题，但将其具体化为针对特定工具（如 Claude Code）的使用策略具有参考价值。论证较为理性，特别是关于注意力管理的讨论。不足之处在于对“规划”的具体颗粒度缺乏明确标准。

  • 实用价值（8/10）：

    • 具有较高的参考意义。文章提供了一种可操作的工作流思路，对于希望减少琐碎重复劳动、提高交付质量的开发者而言，这种模式值得尝试。

  • 创新性（6/10）：

    • 方法论上属于敏捷开发与 AI 辅助的结合，概念上并非颠覆性创新。但在工具应用层面，它重新定义了开发者与 IDE 的交互方式，将 AI 从辅助工具提升为执行代理。

  • 可读性（8/10）：

    • 逻辑结构清晰，通过工作流对比使抽象概念易于理解。

  • 行业影响：

    • 这种观点的普及可能推动开发工具向“自然语言编程”方向演进。未来的 IDE 可能会进一步分化为逻辑视图和代码视图，以适应人机不同的操作偏好。

  • 争议点：

    • 技能依赖： 长期脱离底层实现可能导致新手开发者对系统细节的感知能力下降。
    • 沟通成本： 对于简单任务，编写精确指令的时间可能超过直接编写代码的时间，导致效率降低。

4. 可验证的检查方式

为了验证该模式的有效性，建议关注以下指标：

  • 代码回滚率
    • 验证方式： 对比“分离模式”与“直接生成模式”下，因逻辑错误或不符合预期而回滚代码的频率。
  • 任务交付周期
    • 验证方式： 记录在包含需求变更的场景下，两种模式从开始到完成验证所需的总时间。
  • 认知疲劳度
    • 验证方式： 评估开发者在长时间工作后，对代码逻辑细节的把控能力是否因模式不同而产生差异。

代码示例

 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

# 示例1：任务规划器 - 将复杂任务分解为可执行的子任务
class TaskPlanner:
    def __init__(self):
        self.tasks = []
    
    def add_task(self, description, priority=1):
        """添加新任务到规划列表"""
        self.tasks.append({
            'description': description,
            'priority': priority,
            'status': 'pending'
        })
    
    def plan_execution(self):
        """生成执行计划，按优先级排序"""
        return sorted(self.tasks, key=lambda x: -x['priority'])
    
    def execute_next(self):
        """执行下一个待处理任务"""
        pending = [t for t in self.tasks if t['status'] == 'pending']
        if not pending:
            return "所有任务已完成"
        
        task = pending[0]
        task['status'] = 'completed'
        return f"执行任务: {task['description']}"

# 使用示例
planner = TaskPlanner()
planner.add_task("分析数据", priority=3)
planner.add_task("生成报告", priority=2)
planner.add_task("发送邮件", priority=1)

print("执行计划:", [t['description'] for t in planner.plan_execution()])
print(planner.execute_next())
print(planner.execute_next())

 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

# 示例2：代码审查流程 - 分离审查和修复阶段
class CodeReview:
    def __init__(self, code):
        self.code = code
        self.issues = []
    
    def review(self):
        """规划阶段：识别代码问题"""
        if len(self.code) > 100:
            self.issues.append("代码过长，建议拆分")
        if 'TODO' in self.code:
            self.issues.append("包含未完成的TODO项")
        if not self.code.strip().endswith('\n'):
            self.issues.append("缺少结尾换行符")
        return self.issues
    
    def fix_issues(self):
        """执行阶段：修复已识别的问题"""
        fixes = []
        if "代码过长" in str(self.issues):
            self.code = self.code[:50] + "\n# ... 代码已拆分\n" + self.code[50:]
            fixes.append("已拆分长代码")
        if "TODO" in str(self.issues):
            self.code = self.code.replace('TODO', 'FIXME')
            fixes.append("已标记待办事项")
        if "缺少结尾换行符" in str(self.issues):
            self.code += '\n'
            fixes.append("已添加结尾换行")
        return fixes

# 使用示例
code_sample = "def long_function():\n    # TODO: 实现这个函数\n    return 42"
reviewer = CodeReview(code_sample)

print("审查结果:", reviewer.review())
print("修复措施:", reviewer.fix_issues())
print("修复后代码:\n", reviewer.code)

 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

# 示例3：自动化测试流程 - 分离测试计划和执行
class TestRunner:
    def __init__(self):
        self.test_cases = []
        self.results = []
    
    def plan_tests(self, module):
        """规划阶段：为模块生成测试计划"""
        if module == "math":
            self.test_cases = [
                {"name": "加法测试", "func": lambda: 2 + 2 == 4},
                {"name": "除法测试", "func": lambda: 10 / 2 == 5}
            ]
        elif module == "string":
            self.test_cases = [
                {"name": "拼接测试", "func": lambda: "a" + "b" == "ab"},
                {"name": "长度测试", "func": lambda: len("test") == 4}
            ]
        return [tc["name"] for tc in self.test_cases]
    
    def execute_tests(self):
        """执行阶段：运行所有计划的测试"""
        self.results = []
        for test in self.test_cases:
            try:
                passed = test["func"]()
                self.results.append({
                    "name": test["name"],
                    "status": "通过" if passed else "失败"
                })
            except Exception as e:
                self.results.append({
                    "name": test["name"],
                    "status": f"错误: {str(e)}"
                })
        return self.results
    
    def generate_report(self):
        """生成测试报告"""
        passed = sum(1 for r in self.results if r["status"] == "通过")
        return f"测试完成: {passed}/{len(self.results)} 通过"

# 使用示例
runner = TestRunner()
print("测试计划:", runner.plan_tests("math"))
print("测试结果:", runner.execute_tests())
print(runner.generate_report())

案例研究

1：某金融科技公司的遗留系统重构

1：某金融科技公司的遗留系统重构

背景: 该公司拥有一套运行了10年的核心交易系统，代码库超过50万行，缺乏文档，且维护团队人员流动频繁。新接手的技术负责人需要在不中断业务的前提下，逐步重构系统。

问题:

  • 系统逻辑极其复杂，直接阅读代码难以理解业务全貌
  • 重构过程中容易引入未知bug
  • 团队成员对系统理解程度不一，沟通成本高

解决方案: 技术团队采用了"规划与执行分离"的工作流程：

  1. 规划阶段：使用Claude Code分析现有代码库，生成详细的数据流图、业务逻辑文档和重构计划。团队与AI进行多轮对话，确认重构的可行性和风险点。
  2. 执行阶段：基于确认的计划，使用传统IDE进行实际编码，关键模块由AI生成初始代码框架，再由工程师审核和优化。

效果:

  • 重构计划制定时间从2周缩短至3天
  • 代码审查效率提升40%，因为AI生成的文档使业务逻辑更清晰
  • 重构后系统性能提升25%，未出现重大业务中断

2：某SaaS创业公司的MVP快速迭代

2：某SaaS创业公司的MVP快速迭代

背景: 一家处于A轮融资阶段的SaaS公司，需要在3个月内完成从0到1开发一个企业级数据分析平台。团队只有5名全栈工程师。

问题:

  • 需求变化频繁，产品经理与开发团队沟通存在理解偏差
  • 工程师既要理解业务又要实现代码，容易陷入细节忽略整体架构
  • 进度紧张，没有足够时间编写详细技术文档

解决方案: 团队建立了AI辅助的敏捷开发流程：

  1. 规划阶段：产品经理与Claude Code协作，将需求转化为结构化的技术方案和API设计文档。AI会主动指出潜在的技术风险和架构问题。
  2. 执行阶段：工程师基于确认的技术方案进行开发，遇到具体实现问题时再向AI寻求代码示例和最佳实践。

效果:

  • 需求理解偏差减少70%，返工率显著下降
  • MVP按时上线，且代码质量高于团队以往平均水平
  • 后续新员工入职时，AI生成的技术文档成为重要参考资料

3：某电商公司的自动化测试系统建设

3：某电商公司的自动化测试系统建设

背景: 该电商平台拥有超过200个微服务，但自动化测试覆盖率不足30%。每次大促前都需要大量人工回归测试，成本高且效率低。

问题:

  • 测试用例设计依赖个人经验，覆盖不全面
  • 编写测试代码枯燥，工程师积极性不高
  • 业务逻辑变化快，测试用例维护成本高

解决方案: 测试团队采用AI驱动的测试开发流程：

  1. 规划阶段：Claude Code分析代码变更和用户行为日志，自动生成测试场景建议和边界条件清单。测试工程师与AI讨论确定最终测试策略。
  2. 执行阶段：基于确定的测试策略，AI生成测试代码框架，工程师补充断言逻辑和特殊场景处理。

效果:

  • 测试覆盖率在2个月内提升至65%
  • 测试用例编写效率提升3倍
  • 最近一次大促期间，通过自动化测试拦截了12个潜在严重bug
  • 测试团队从"找bug"转向"设计测试策略"，工作满意度提升

最佳实践

最佳实践指南

实践 1：明确分离规划与执行阶段

说明: 将使用 Claude Code 的过程明确分为两个独立阶段：首先是规划阶段，用于理解需求和设计解决方案；然后是执行阶段，用于实际编写代码和实现功能。这种分离可以避免过早陷入实现细节，确保整体架构的合理性。

实施步骤:

  1. 在开始任何编码工作前，先与 Claude 进行纯文本对话，明确需求
  2. 让 Claude 生成详细的实现计划和架构设计
  3. 审查并确认计划后再进入执行阶段
  4. 在执行阶段严格遵循已确定的计划

注意事项: 不要在规划阶段就要求 Claude 生成代码，这会导致注意力分散到实现细节上

实践 2：使用自然语言详细描述需求

说明: 在规划阶段，用清晰的自然语言描述问题、目标和约束条件，而不是直接跳到代码层面。这有助于 Claude 更好地理解上下文和意图。

实施步骤:

  1. 描述当前问题的背景和上下文
  2. 明确说明期望达到的目标
  3. 列出任何技术约束或偏好
  4. 说明相关的业务逻辑或领域知识

注意事项: 避免使用过于技术化的术语，保持描述的清晰性和完整性

实践 3：要求生成结构化的实施计划

说明: 让 Claude 在规划阶段生成结构化的实施计划，包括步骤、文件结构、关键决策点等，而不是直接生成代码。

实施步骤:

  1. 明确要求 Claude 生成实施计划而非代码
  2. 要求计划包含具体的实施步骤
  3. 要求列出需要创建或修改的文件
  4. 要求说明关键技术决策和理由

注意事项: 审查生成的计划，确保其合理性和完整性后再继续

实践 4：分阶段验证和确认

说明: 在每个主要阶段完成后进行验证，确保方向正确后再继续下一阶段，避免在错误的方向上浪费太多时间。

实施步骤:

  1. 在规划阶段完成后，确认计划符合预期
  2. 在每个主要功能模块实现后，进行代码审查
  3. 在集成测试前，确认各模块的正确性
  4. 在最终部署前，进行完整的系统验证

注意事项: 不要跳过验证步骤，及时发现和纠正问题

实践 5：保持上下文的连续性

说明: 在整个对话过程中保持上下文的连续性，确保 Claude 能够记住之前的决策和讨论，避免重复解释或冲突。

实施步骤:

  1. 在对话开始时提供足够的背景信息
  2. 在切换话题时明确说明上下文的变化
  3. 定期总结已达成的一致意见和决策
  4. 在长时间对话后，简要回顾之前的讨论要点

注意事项: 避免在同一个对话中处理完全不相关的问题

实践 6：利用 Claude 的代码审查能力

说明: 在执行阶段，让 Claude 帮助审查生成的代码，确保代码质量、一致性和最佳实践的应用。

实施步骤:

  1. 在代码生成后，要求 Claude 进行自我审查
  2. 询问代码中可能存在的问题或改进空间
  3. 要求检查代码是否符合最佳实践和编码规范
  4. 验证错误处理和边界条件的考虑

注意事项: 不要盲目接受生成的代码，始终保持批判性思维

实践 7：建立迭代反馈循环

说明: 将整个过程视为一个迭代过程，通过不断的反馈和改进来逐步完善解决方案，而不是期望一次性得到完美结果。

实施步骤:

  1. 在每个迭代结束时评估结果
  2. 识别需要改进的地方
  3. 将反馈整合到下一轮的规划中
  4. 持续优化直到达到满意的结果

注意事项: 保持灵活性，根据反馈及时调整方向

学习要点

  • 将编程任务拆分为“规划”和“执行”两个独立阶段，避免AI在未理清思路前直接生成代码。
  • 在规划阶段，要求AI先输出伪代码、流程图或分步逻辑，而非直接编写可执行代码。
  • 执行阶段时，让AI基于已确认的规划逐步实现代码，减少反复修改的次数。
  • 通过明确区分两个阶段，可以更精准地定位问题（如规划错误或实现错误）。
  • 使用工具（如Claude Code）的“暂停-继续”功能，在规划完成后手动触发执行。
  • 这种分离模式尤其适用于复杂任务，能显著提升代码质量和开发效率。
  • 定期让AI回顾已完成的规划，确保执行方向与初始目标一致。

常见问题

1: 为什么在编程任务中需要将"规划"和"执行"分离？

1: 为什么在编程任务中需要将"规划"和"执行"分离？

A: 将规划与执行分离主要基于认知负荷管理和代码质量的考虑。在编程过程中，如果同时思考架构设计和具体实现细节，容易导致逻辑混乱。规划阶段专注于理解需求、设计架构和确定技术方案；执行阶段则专注于编码实现、调试和优化。这种分离可以避免频繁切换上下文带来的效率损失，同时确保每个阶段都能得到充分的思考。特别是在使用AI辅助编程时，明确的规划阶段能帮助生成更准确、更符合整体架构的代码。

2: 在Claude Code中如何有效实施这种分离？

2: 在Claude Code中如何有效实施这种分离？

A: 实施这种分离通常包括以下步骤：首先，在规划阶段，通过对话明确需求边界、输入输出格式、异常处理策略等；然后让Claude生成详细的实现计划或伪代码；接着在执行阶段，严格按照规划好的方案进行编码。关键是要避免在编码过程中随意修改规划，如果发现规划有问题，应该回到规划阶段重新讨论，而不是直接在代码中"打补丁"。这种工作方式特别适合处理复杂业务逻辑或需要多人协作的项目。

3: 这种工作方式是否会降低开发效率？

3: 这种工作方式是否会降低开发效率？

A: 短期来看，额外的规划阶段确实会增加前期时间投入，但长期来看通常会提高整体效率。原因包括：1) 减少返工次数，因为规划阶段已经考虑了大部分边界情况；2) 代码质量更高，减少了调试时间；3) 更容易维护和扩展，因为架构决策经过深思熟虑。对于简单任务可能显得过度设计，但对于复杂系统或需要长期维护的项目，这种投入是非常值得的。

4: 当规划与实际情况不符时，应该如何处理？

4: 当规划与实际情况不符时，应该如何处理？

A: 这种情况在开发中很常见，处理原则是：优先回到规划阶段进行调整，而不是直接修改代码。具体做法包括：1) 记录实际执行中遇到的问题；2) 分析是规划本身的缺陷还是实现过程中的偏差；3) 与团队或AI重新讨论调整方案；4) 更新规划文档后再继续执行。这样可以保持规划与执行的一致性，避免代码与文档脱节，也有助于知识积累和团队协作。

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

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

A: 并非所有任务都适合这种严格的分离。对于以下情况，规划与执行的分离特别有价值：1) 复杂业务逻辑的实现；2) 需要多人协作的大型项目；3) 对可靠性要求高的系统；4) 需要长期维护的代码库。而对于以下情况可能不需要：1) 简单的脚本或工具；2) 快速原型验证；3) 一次性任务；4) 探索性编程。关键是要根据项目特点灵活调整，而不是机械地套用方法。

6: 如何在团队环境中推广这种工作方式？

6: 如何在团队环境中推广这种工作方式？

A: 在团队中推广这种工作方式需要：1) 建立明确的文档规范，要求规划产出必须包含架构图、接口定义、测试策略等；2) 在代码评审中同时检查规划文档的完整性和代码实现的一致性；3) 使用工具支持，比如将规划文档与代码仓库关联；4) 培养团队习惯，从简单的任务开始实践，逐步推广到复杂项目；5) 定期复盘，总结哪些情况下这种分离带来了实际价值，哪些情况下可以简化流程。

思考题

## 挑战与思考题

### 挑战 1: [简单]

问题**: 在使用 AI 编程助手时，如何通过提示词设计明确区分"规划阶段"和"执行阶段"？请设计一个包含两个明确阶段的提示词模板，用于完成一个简单的文件重构任务。

提示**: 考虑在提示词中使用明确的分隔符（如 “### 规划阶段” 和 “### 执行阶段”），并要求 AI 在完成规划后等待你的确认再开始执行。

引用

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

站内链接

相关文章