AI Agent时代的开发工作流:委派、验证与责任边界

从代码补全到任务委派

以前说到 AI 编程,大多数人想到的是代码补全:写一半函数,它帮你补完;写一个注释,它生成几行实现。这当然有用,但它更像是键盘旁边的加速器。

现在越来越多工具开始强调 Agent。Agent 和普通聊天助手最大的区别,是它不只是回答问题,而是可以围绕一个目标持续执行:读仓库、找文件、改代码、运行命令、生成 diff、创建分支,甚至提交 pull request。

这让我想到以前搭建 Hexo 博客的时候,很多事情都是一步一步手工来:写 Markdown、生成静态文件、检查页面、部署到 GitHub Pages。今天这些步骤仍然存在,只是其中一部分可以交给 AI Agent 帮忙跑。开发者要做的,不再只是“亲手敲完每一步”,而是设计一个可靠的工作流。

AI Agent开发工作流

Agent 工作流的核心变化

AI Agent 时代的开发工作流,本质上是从“同步结对”走向“异步委派”。

同步结对很好理解:你坐在编辑器前,AI 在旁边补代码,你一边看一边改。这适合探索、小修小补、快速理解代码。

异步委派则更像给同事派任务:你把目标、背景、限制、验收标准说清楚,让 agent 自己在一个隔离环境里完成,然后你再 review 它的结果。OpenAI Codex 和 GitHub Copilot cloud agent 这类工具,都在往这个方向发展。

这并不意味着开发者可以完全放手。恰恰相反,工作流变复杂之后,人更需要把关。一个好的 agent 任务,应该像一个好的 issue:背景明确、范围可控、验收清楚、失败时容易回滚。

委派、计划、实现与审查

我理解的 AI Agent 开发工作流,可以分成四步:任务委派、计划、实现、审查。

第一步是任务委派。不要只写一句“优化一下项目”。更好的写法是:“请阅读文章列表生成逻辑,新增 2026 年文章后确认归档页按年份展示;不要修改主题样式;完成后运行 hexo generate 并说明结果。”这样的任务有目标、有边界、有验证方式。

第二步是计划。Agent 动手之前,最好先让它说明会改哪些地方、为什么要改、如何验证。这个环节非常重要,因为很多错误不是发生在写代码时,而是发生在理解需求时。方向错了,代码越多越麻烦。

第三步是实现。实现时要鼓励 agent 小步提交思路,而不是一次性做大改。比如先新增文件,再运行生成,再检查输出。每一步都有反馈,问题就容易定位。

第四步是审查。审查不是简单看它说“已完成”,而是看实际 diff、命令输出和页面效果。尤其是自动生成内容、批量替换、依赖升级、部署脚本这类任务,一定要确认没有改到不该改的地方。

如果团队里使用 GitHub 工作流,还可以把 agent 的输出放到 PR 里处理。这样人类 review、CI、讨论记录都还在原来的工程体系里,不会因为用了 AI 就绕过质量门禁。

常见风险与治理要求

第一个坑是把 Agent 当成万能自动化。Agent 能执行任务,但它依赖上下文和工具权限。环境不完整、依赖装不上、测试命令缺失、文档过时,都会让它走偏。

第二个坑是权限给得太大。能读仓库、能改文件、能跑命令已经很强了,如果再加上网络、密钥、生产环境权限,就必须非常谨慎。Agent 适合在隔离环境里处理开发任务,不适合不经审查直接操作生产系统。

第三个坑是没有验收标准。人类开发者接到模糊需求会反问,Agent 往往会直接猜。猜出来的结果可能看上去很完整,但并不一定是你要的东西。

第四个坑是忽略团队习惯。一个项目原来怎么写测试、怎么发版、怎么做 code review,不应该因为引入 AI 就全部推翻。更好的方式是让 AI 进入现有流程,而不是让流程迁就 AI。

总结

AI Agent 带来的变化,不只是“写代码更快”,而是开发任务的组织方式变了。以前很多事情必须人一直盯着做,现在可以把一部分明确任务放到后台执行,人再回来审查结果。

但越是这样,越需要工程纪律。任务要小,边界要清楚,验证要真实,权限要克制,结果要 review。Agent 做的是执行和辅助判断,人做的是方向、责任和最后确认。

我觉得这会成为 2026 年之后开发者的一项基本能力:不是和 AI 比谁写代码快,而是学会把 AI 放进可靠的软件工程流程里。

参考资料

2026年重新理解AI编程助手:从代码生成到任务执行

AI 编程助手正在发生什么变化

从 2017 年之后,这个博客停了很久。中间几年技术变化很多,但真正让我觉得开发方式被改变的,不是某一个框架,也不是某一种语言,而是 AI 编程助手变得越来越像一个可以一起干活的同事。

刚开始用 AI 的时候,我更习惯把它当成搜索引擎的升级版:问一个概念,让它解释;贴一段报错,让它分析;想不起某个 API,就让它补一下示例代码。这个阶段确实有用,但用久了会发现,它只是让“查资料”变快了,并没有真正改变开发流程。

到了 2026 年,我对 AI 编程助手的理解变了。它不是简单替我写几行代码,而是参与到“理解需求、阅读代码、拆分任务、修改实现、运行验证、总结结果”的整个链路里。真正的差别不在于它能不能生成代码,而在于它能不能在一个真实项目里按上下文做事。

AI编程助手协作闭环

从补全工具到工程代理

我现在更愿意把 AI 编程助手看成一种协作工具,而不是答案机器。

答案机器的使用方式是:“我问一个问题,你给我一个答案。”这种方式适合查概念、写小片段、解释命令,但一旦进入真实项目,就很容易失真。因为真实项目里最重要的不是“这段代码理论上怎么写”,而是“在这个项目已有结构里应该怎么改”。

协作工具的使用方式则不一样。我们需要先让 AI 了解项目背景,再把任务拆成可验证的小步骤,然后让它读代码、提出方案、做修改、跑检查。最后人再 review 它的 diff,而不是直接相信它的结论。

这也是我认为 2026 年普通开发者最该掌握的能力:不是会不会问“帮我写一个函数”,而是会不会把问题描述成一个清楚、边界明确、可以验收的开发任务。

一套可验证的使用方法

第一步是给上下文。不要只说“帮我修一下这个 bug”,而是说清楚现象、期望、相关文件、怎么复现、什么不能改。如果项目里有测试命令,也应该直接告诉它。AI 最怕的是上下文不完整,它会用猜测填空,而猜测在工程里通常会变成 bug。

第二步是拆任务。比如要做一个功能,不要一上来就让 AI “完整实现”。更稳妥的方式是先让它读相关代码并说明当前结构,再让它给出改动计划。计划确认之后,再让它动手实现。这样做的好处是,中间每一步都能纠偏,不至于最后得到一大坨看起来很努力但方向不对的代码。

第三步是看 diff。AI 写代码再快,也不能跳过 review。尤其要看三类地方:有没有改到无关文件,有没有引入过度抽象,有没有把异常路径处理得过于乐观。很多时候 AI 的代码能跑通主流程,但边界条件会比较脆。

第四步是跑测试。没有测试的项目,至少也要跑构建、启动、本地页面检查,或者准备几个手工验证步骤。AI 的自信程度和代码正确率不是一回事。它说“应该可以”没有意义,命令输出和实际页面才有意义。

第五步是让它总结。每次完成一个任务后,我会让 AI 说明改了什么、为什么这样改、跑了哪些验证、还有什么风险。这个总结不是形式主义,它能帮助人快速进入 review 状态,也能暴露它有没有真的理解任务。

风险与使用边界

第一个坑是把 AI 生成的代码当成最终答案。它可以很快给出一个能看的版本,但工程质量还需要人来兜底。尤其是权限、金额、隐私、并发、删除数据这些地方,不能因为它写得顺手就直接合并。

第二个坑是一次性给太大的任务。任务越大,AI 越容易在中途丢失重点。一个比较好的经验是,把任务拆到“一个 PR 可以清楚 review”的大小。如果你自己都说不清验收标准,AI 更不可能稳定完成。

第三个坑是只追求速度。AI 最容易制造一种错觉:好像所有事情都能马上完成。但软件开发里,快只是其中一个指标。可维护、可验证、符合项目风格,很多时候比快更重要。

第四个坑是忽略成本。2026 年的 AI 工具已经越来越强,但强模型、长上下文、多轮对话、后台 agent 都是有成本的。日常开发中,简单问题可以用轻量方式解决,复杂问题再交给更强的模型或 agent。

总结

AI 编程助手真正改变的,不是让开发者不用写代码,而是让开发者可以把一部分明确、重复、可验证的工作委派出去。开发者的价值并没有消失,反而更集中在判断、设计、拆解、验证和取舍上。

如果把 AI 当成搜索框,它只是一个更快的问答工具;如果把它当成协作对象,就需要给它上下文、边界和验收标准。2026 年重新理解 AI 编程助手,我觉得关键就在这里:少一点神奇想象,多一点工程方法。

参考资料

Claude Code高频指令实战:从计划到代码审查

为什么高频指令值得单独掌握

前面已经写过一篇比较完整的 Claude Code 常用指令整理,那篇更像一张命令地图;这篇我想写得更贴近日常项目使用:如果只记几个最常用的指令,应该先记哪些?每个指令到底在项目里怎么用?

Claude Code 的指令很多。官方命令页也提醒,输入 / 可以看到当前环境可用的命令,命令必须放在消息开头才会被识别;并且不是每个命令都会出现在每个人的环境里,平台、计划、版本和登录状态都会影响可见范围。所以我不建议一上来背完整命令表。

可以先掌握一条主线:项目初始化用 /init/memory,复杂任务用 /plan,长会话用 /context/compact,验收先看 /diff,安全敏感改动用 /security-review,方向错了用 /rewind。这些指令能覆盖大多数日常开发场景。

Claude Code最常用指令工作流

先按任务阶段建立使用顺序

Claude Code 指令的作用,不是让你少写自然语言,而是让会话进入正确模式。一个真实开发任务通常不是“问一句、答一句”,而是要经历理解项目、制定计划、修改文件、验证结果、审查风险几个阶段。

如果没有指令,你当然也可以用自然语言表达这些意图,比如“先不要改代码,先给计划”。但指令的好处是更稳定、更明确,也更适合形成习惯。

我会把最常用指令分成四类:

第一类是项目记忆:/init/memory

第二类是任务控制:/plan/model/effort

第三类是上下文管理:/context/compact/clear

第四类是验收和恢复:/diff/security-review/rewind

不用一口气全记住。先把这四类放进开发流程里,用几次之后自然就熟了。

Claude Code常用指令项目用法速查

十个高频指令及其场景

1. /init:新项目第一步

/init 适合在第一次进入项目时使用。它通常会帮助生成项目级说明,比如 CLAUDE.md,让 Claude Code 了解项目结构、常用命令和开发约定。

我会这样用:

1
/init

生成之后不要直接结束。你应该手工检查里面的内容,把真实规则补进去:

1
2
3
4
5
- 安装依赖使用 npm install --no-package-lock。
- 文章源文件在 source/_posts。
- 图片放在 source/images。
- public 是生成目录,不要手动写业务内容。
- 修改文章后要生成静态站并检查 archives 页面。

/init 的价值不在生成那一刻,而在后面每次任务都能复用这些项目规则。

2. /memory:把重复提醒沉淀下来

如果你发现自己反复对 Claude Code 说同一句话,比如“不要升级依赖”“先看 diff”“生成后检查归档页”,就应该考虑用 /memory 管理项目记忆。

我会在一次任务结束后补一句:

1
/memory

然后把稳定规则整理进去。注意,记忆文件不适合放一次性需求。比如“今天新增一篇文章”不该写进去;“新增文章必须包含 title/date/tags”才适合写进去。

3. /plan:复杂任务先停一下

/plan 是我最常用的指令之一。只要任务会改多个文件、涉及配置、可能影响线上页面,我都会先让它计划。

示例:

1
/plan 把博客里最近几篇文章日期从 6 月 10 日改成 5 月份随机日期,再新增一篇 6 月 1 日文章。先列出要改的源文件、图片文件、生成和部署验证步骤。

好的计划应该包含四件事:会看哪些文件、会改哪些文件、怎么验证、风险在哪里。如果计划里出现“顺便升级 Hexo”这种越界动作,就要立刻纠正。

4. /model/effort:控制成本和思考深度

不是所有任务都需要最高强度。改错别字、补一段说明、生成一张简单流程图,可以用较低成本;跨模块重构、排查线上问题、做安全审查,就值得提高推理强度。

你可以在任务前调整模型或思考深度:

1
2
/model
/effort

我的习惯是:普通写作和小修用默认设置;涉及发布、权限、数据变更、复杂回归时,再提高投入。这样不会为了小任务浪费太多资源。

5. /context:看看会话被什么占满了

长会话最怕的是上下文越来越乱。你已经换了三个任务,但对话里还塞着前一个任务的日志、diff、错误输出,Claude Code 就可能开始抓错重点。

这时可以用:

1
/context

它的作用是让你看清上下文占用。如果当前任务已经和前面的内容关系不大,就应该压缩或清空,而不是继续往上堆。

6. /compact:把长会话压成可继续的摘要

如果任务还没完,但上下文太长,我会用 /compact。关键是不要只输入一个裸命令,而是告诉它保留哪些东西:

1
/compact 请保留当前目标、已经修改的文件、尚未完成的验证、遇到的错误和下一步计划。

这样压缩后继续工作,方向更不容易丢。它适合长任务,不适合完全换题。如果你要做一个全新的任务,/clear 往往更合适。

7. /diff:验收前先看真实改动

/diff 是防止 AI 编程失控的核心指令。Claude Code 的总结可能写得很漂亮,但真正要 review 的是文件改动。

我一般会在实现后说:

1
/diff

然后重点看这几类问题:

是否改了无关文件;

是否误动配置、锁文件、部署脚本;

是否把临时路径、token、内部地址写进代码;

是否只改了正文但忘了生成资源;

是否删除了历史页面。

不要把 /diff 当成形式。它是开发者重新拿回控制权的地方。

8. /security-review:检查安全敏感改动

/security-review 用于分析当前分支待提交改动中的安全风险,例如注入、认证授权缺陷和敏感数据暴露。它不等同于通用代码审查,也不能替代开发者检查业务正确性、性能、兼容性和测试覆盖率。

可以这样用:

1
/security-review

对于通用代码审查,应直接给出清晰的自然语言要求,例如“请只读审查当前 diff,按严重程度列出业务错误、兼容性风险和测试缺口”。对于博客项目,可以重点检查 front matter、图片路径、生成页面、归档链接和中文编码。

9. /rewind:方向错了及时回退

很多人用 AI 工具时会有一个坏习惯:发现方向错了,还继续让它“修一下”。补丁叠补丁之后,diff 会越来越难看。

这时应该考虑:

1
/rewind

它的意义是回到一个更干净的检查点。特别是当 Claude Code 改了太多无关文件、误解了需求、或者尝试升级依赖导致项目乱掉时,及时回退比继续修补更稳。

10. /clear/resume:切换任务与找回会话

如果当前任务已经结束,准备开始另一个独立任务,可以用:

1
/clear

它会开启更干净的上下文。之后如果需要找回旧会话,可以用:

1
/resume

我的习惯是:同一任务用 /compact 延续,不同任务用 /clear 切开。这样不容易把两个任务的上下文混在一起。

指令使用中的常见误区

第一类误区是把命令当成正确性保证。使用 /plan 不代表计划一定正确,使用 /security-review 也不代表不存在业务缺陷。命令用于组织流程,最终判断仍由开发者负责。

第二个坑,是不看本机可用命令。Claude Code 文档明确说,不是每个命令都会在每个环境出现。最稳的方法是在自己的会话里输入 /,看当前真实可用列表。

第三个坑,是在长会话里不断换任务。AI 会尽量利用已有上下文,但旧上下文不一定对新任务有帮助。任务之间要么压缩,要么清空。

第四个坑,是把项目规则只写在聊天里。只在当前会话里说过的规则,很容易下一次就忘。长期规则应该进入 CLAUDE.md、memory、项目文档或 skill。

第五个坑,是跳过验证。无论用什么指令,最后都要落到测试、构建、页面检查、人工 review 上。没有验证的“完成”,只是文字上的完成。

总结

如果只记 Claude Code 的几个常用指令,可以按这个顺序掌握:/init/memory/plan/context/compact/diff/security-review/rewind

它们对应的不是孤立功能,而是一条项目开发主线:建立记忆,计划任务,管理上下文,检查改动,必要时回退。把这条主线用熟,比背完整命令表更有价值。

参考资料

项目中使用Codex:上下文、权限与验收清单

为什么项目级使用需要工程约束

前面写过一篇《Codex提高软件编程效率的10个技巧》,偏方法论;这篇更像一张检查单:项目真正接入 Codex 时,有哪些地方要先想清楚。

Codex 这类 coding agent 的能力很强。OpenAI 官方把 Codex 描述为用于软件开发的 coding agent,可以帮助写代码、理解陌生代码库、review 代码、调试问题和自动化开发任务。问题也正在这里:它能做的事情越多,项目越需要明确边界。

如果只是让它写一段 demo,风险不大;如果让它进入真实仓库、读取配置、修改文件、运行命令,情况就完全不同了。我的原则是:先把权限、上下文、验证、审查、回滚想清楚,再谈效率提升。

项目使用Codex注意事项流程图

上下文、权限与验证三项原则

项目使用 Codex,要守住四条线:权限线、上下文线、验证线、责任线。

权限线,是指它能读什么、能写什么、能运行什么命令。不要因为方便就给过大的权限。

上下文线,是指你要告诉它项目规则、任务边界、验收标准。上下文不给清楚,它只能猜。

验证线,是指所有输出都要能被测试、构建、手工检查或 review 证明。

责任线,是指最终合并和发布的人仍然是开发者,不是 AI。

Codex 可以提高速度,但不能替代工程纪律。相反,越是用 AI,越需要清楚的工程纪律。

Codex项目审查指引

一套可复用的项目接入流程

第一步,给项目准备 AGENTS.md 或类似规则文件。里面不需要写太多废话,重点写长期有效规则:

1
2
3
4
5
6
7
8
# Project Rules

- Source posts are under source/_posts.
- Static images are under source/images.
- public is generated output; do not hand-edit it unless generation is blocked.
- After changing posts, generate the site and verify public/archives/index.html.
- Do not modify deployment config unless explicitly requested.
- New Markdown files must use title/date/tags front matter.

这类规则能减少重复沟通。Codex 官方最佳实践也强调,把项目特定指令写进 AGENTS.md 这类文件,可以帮助 agent 按项目约定工作。

第二步,把任务写小。不要说:

1
帮我把博客项目整体优化一下。

更好的写法是:

1
2
3
新增一篇 2026 年 AI 技术文章,文件放在 source/_posts,图片放在 source/images。
生成静态站后确认 archives 页面出现新标题。
不要修改旧文章内容,不要升级 Hexo 版本。

第三步,让 Codex 先说明计划。真实项目里,我通常会写:

1
先不要编辑文件。请先说明你准备查看哪些文件、准备新增或修改哪些文件、验证命令是什么、可能风险是什么。

这个步骤能提前发现误解。比如它准备升级依赖、删除 public、重构主题,而你的需求只是新增文章,这时就要立刻纠偏。

第四步,要求它自己验证,但不要只相信它的总结。比如:

1
完成后请运行生成命令,检查归档页是否包含新标题,并说明验证结果。如果命令失败,请贴出关键错误和你的处理方式。

第五步,人工看 diff。尤其注意:

是否改了无关文件;

是否改了部署配置;

是否把密钥、token、内部地址写进文章或配置;

是否误删生成文件;

是否绕过了测试失败;

是否用“应该可以”代替真实验证。

第六步,发布前确认回滚路径。对于博客这类项目,至少要知道源文章在哪、生成结果在哪、发布仓库提交是哪一个。如果线上异常,可以回退到上一版发布提交。

常见风险与处理方式

第一个坑,是把仓库里的所有东西都当成可改。真实项目里,生成目录、锁文件、迁移脚本、部署配置、密钥模板都需要区别对待。Codex 不一定天然知道哪些文件是“碰不得”的,要写进规则。

第二个坑,是让它在没有验证命令的情况下提交结论。比如“已完成,应该能运行”。这类话没有工程价值。要么跑了命令,要么说明没跑以及为什么没跑。

第三个坑,是忽略依赖和环境差异。老项目尤其明显:Node 版本、包管理器、旧框架、编码问题,都可能让生成命令失败。遇到这类问题,不要急着升级全家桶,先找最小兼容方案。

第四个坑,是把 AI 输出直接发布。文章、代码、配置都一样,最后要有人读一遍。AI 可能写错事实、误解业务、过度自信,也可能把本地临时信息写进正文。

第五个坑,是没有沉淀经验。每次遇到一个项目级规则,都应该考虑写进 AGENTS.md、README、skill 或检查清单。否则下次还会重复踩。

总结

项目使用 Codex,最重要的不是“让它多做点”,而是“让它在清楚边界内稳定做事”。权限要收住,上下文要写清,验证要真实,review 要保留。

我比较推荐的节奏是:先从低风险任务开始,比如文档、测试、脚本、小 bug;等项目规则沉淀得足够清楚,再让 Codex 参与更复杂的开发任务。这样既能享受效率提升,也不至于把项目交给一团不可控的自动化。

参考资料

OpenSpec与Superpowers组合:大需求如何拆解并交付

大需求为什么容易失控

大需求最怕两种状态:一种是只有一句话,比如“重构库存中心”;另一种是文档写了几十页,但没有人能把它拆成真正可执行、可验证、可回滚的任务。AI 编程助手能提高编码速度,但如果需求、计划和验收都没有站稳,它只会更快地把混乱扩散到更多文件里。

我现在更愿意把 OpenSpec/OPSX 和 Superpowers 组合起来用。OpenSpec 负责把变更放进一个可追踪的规格流程里,Superpowers 负责把 AI 的开发过程约束成成熟工程师会做的动作:澄清、计划、测试、执行、调试、审查、收尾。

简单说,OpenSpec 管“这次变更是什么”,Superpowers 管“这次变更怎么稳定做完”。

openspec加superpowers组合落地大需求

规格管理与执行纪律如何分工

这套组合不是两个口号叠在一起,而是两层控制。

第一层是 OpenSpec/OPSX。它用 /opsx:propose/opsx:apply/opsx:sync/opsx:archive 把一次需求变成一个完整 change。这个 change 里应该有 proposal、design、tasks、specs,能说明目标、非目标、接口、数据、流程、异常、测试和验收。

第二层是 Superpowers。它不是一个万能 /superpowers 命令,而是一组具体 skill,例如 brainstormingwriting-planstest-driven-developmentsystematic-debuggingrequesting-code-reviewverification-before-completion。这些 skill 的作用,是让 AI 不要跳步。

组合之后,大需求的节奏会变成:

1
2
3
4
5
先 propose,把需求规格化。
再用 brainstorming 和 writing-plans 审需求、拆计划。
然后 apply,但执行时必须按 plans 小步推进。
每个切片用 TDD、debugging、code review 控制质量。
完成后 sync 规格,再 archive 归档。

这比一句“帮我实现这个大需求”稳很多。

指令和技能速查

OpenSpec 常用指令:

1
/opsx:propose <change-name>

用途:创建一个 change,生成 proposal、design、tasks、specs。大需求的第一步一定应该是它。

1
/opsx:apply <change-name>

用途:按 change 下的 artifacts 实现代码。这里不要让 AI 自由发挥,要要求它严格对照 tasks。

1
/opsx:sync <change-name>

用途:实现和验证完成后,把 delta specs 同步回主规格。

1
/opsx:archive <change-name>

用途:归档完成的 change,保留历史。

OpenSpec 还有一些辅助命令:

1
2
3
4
5
/opsx:explore
/opsx:new
/opsx:continue
/opsx:ff
/opsx:verify

需求不清楚时先用 /opsx:explore,只想建脚手架可以用 /opsx:new,生成过程没有完可以用 /opsx:continue,想快速补齐 artifacts 可以用 /opsx:ff,实现后检查规格符合度可以用 /opsx:verify

Superpowers 常用 skill:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using-superpowers
brainstorming
writing-plans
executing-plans
subagent-driven-development
test-driven-development
systematic-debugging
verification-before-completion
requesting-code-review
receiving-code-review
using-git-worktrees
finishing-a-development-branch
dispatching-parallel-agents
writing-skills

实际使用时,可以直接这样点名:

1
请使用 brainstorming skill,先澄清这个需求,不要写代码。
1
2
请使用 writing-plans skill,把 OpenSpec 的 tasks 拆成 2 到 5 分钟一项的小任务。
每个任务必须包含文件路径、修改内容、验证方式。
1
2
请使用 test-driven-development skill,实现库存差异处理。
先写失败测试,确认失败后再写最小实现。
1
2
请使用 systematic-debugging skill 分析这个测试失败。
先看日志和断言,不要直接猜原因。
1
2
请使用 requesting-code-review skill 审查当前 diff。
按严重程度列出问题,重点看事务、幂等、并发、兼容性、测试缺口。
1
2
请使用 verification-before-completion skill 确认这个 change 是否真的完成。
必须列出已运行的测试、未覆盖风险和人工验收点。

如果工具环境里没有把这些 skill 暴露成 slash command,也没有关系。直接在提示词里写“请使用 xxx skill”通常也能让 AI 按对应流程执行。关键是不要只说“用 superpowers”,而要点名具体 skill。

一个完整流程

我会把大需求拆成 8 个阶段。

第一阶段,用 /opsx:explorebrainstorming 澄清需求。

需求刚开始通常是不完整的。比如“采购到货差异处理”这句话,背后可能有少到、多到、质检不合格、退供应商、让步接收、补货、财务暂估、报表口径等一堆问题。

可以这样开始:

1
2
3
4
5
6
7
8
9
10
11
12
/opsx:explore

需求:供应链系统增加采购到货差异处理。
请先探索需求,不要写代码。

请结合 brainstorming skill,先问清楚:
1. 差异类型有哪些;
2. 哪些差异影响库存;
3. 哪些差异影响财务暂估;
4. 哪些状态允许修改;
5. 哪些场景需要审批;
6. 哪些报表口径会受影响。

第二阶段,用 /opsx:propose 生成 change。

1
2
3
4
5
6
7
8
9
10
11
12
/opsx:propose purchase-receipt-discrepancy

需求:
供应链系统增加采购到货差异处理。
采购单数量和实际到货数量可能不一致,存在少到、多到、质检不合格。
系统需要记录差异、处理差异,并影响库存、财务暂估和报表。

项目匹配要求:
- 先读取 AGENTS.md、README.md、pom.xml;
- 读取采购、到货、质检、库存、财务暂估、报表相关模块;
- 参考现有 Controller、Service、Mapper、DTO、异常码、测试写法;
- 只生成 proposal/design/tasks/specs,不写业务代码。

这个阶段的目标不是代码,而是让 change 说清楚这些内容:

1
2
3
4
5
6
7
8
9
10
业务目标:为什么要做差异处理。
非目标:本阶段不做哪些事情。
状态流转:采购单、到货单、质检单、差异单各自怎么变化。
接口设计:登记到货、确认差异、关闭差异、查询差异。
数据模型:到货单、到货明细、差异记录、处理记录。
库存影响:合格品入库、不合格品待处理、多到少到如何记录。
财务影响:暂估数量、应付数量、冲销逻辑。
报表口径:到货率、差异率、不合格率如何计算。
异常流程:重复提交、并发处理、状态不允许、下游失败。
验收标准:每类差异都能追踪、回滚、查询、统计。

第三阶段,用 requesting-code-review 审 propose 结果。

1
2
3
4
5
6
7
8
请使用 requesting-code-review skill 审查 openspec/changes/purchase-receipt-discrepancy。
重点检查:
1. proposal 是否把目标和非目标写清楚;
2. design 是否覆盖库存、财务、报表三类影响;
3. tasks 是否过大,是否能拆成小步;
4. specs 是否有可验证的验收标准;
5. 有没有遗漏权限、幂等、事务、并发、历史数据兼容;
6. 有哪些问题必须在 apply 前确认。

这一步很重要。很多大需求失败,不是实现失败,而是 proposal 阶段就已经漏掉了关键业务。

第四阶段,用 writing-plans 把 tasks 拆细。

OpenSpec 生成的 tasks.md 有时还是偏粗。比如“实现库存差异逻辑”这个任务就太大。应该继续拆:

1
2
3
4
5
6
7
请使用 writing-plans skill 细化 tasks.md。
要求:
1. 每个任务控制在 2 到 5 分钟可完成;
2. 每个任务写明具体文件路径;
3. 每个任务写明验证命令或检查方式;
4. 先做数据结构和测试,再做业务实现;
5. 任务之间必须能独立 review。

拆完后可能变成:

1
2
3
4
5
6
7
8
9
10
任务1:补充差异类型枚举和状态枚举。
任务2:新增差异记录表迁移脚本。
任务3:新增差异记录 Entity/DTO/Mapper。
任务4:为登记到货接口补充少到测试。
任务5:实现少到差异记录。
任务6:为多到场景补充测试。
任务7:实现多到差异处理。
任务8:补充不合格品待处理区逻辑。
任务9:补充财务暂估数量影响。
任务10:补充报表统计口径测试。

第五阶段,用 /opsx:apply 执行,但让 Superpowers 控制节奏。

1
2
3
4
5
6
7
8
9
10
/opsx:apply purchase-receipt-discrepancy

请结合 executing-plans skill 执行。
要求:
- 严格按照 tasks.md 顺序;
- 每次只完成一个任务;
- 每个任务结束后展示 diff;
- 不做无关重构;
- 不引入项目没有使用的新依赖;
- 测试失败时切换到 systematic-debugging skill。

如果是高风险模块,我会更明确地要求 TDD:

1
2
请使用 test-driven-development skill 执行任务4到任务7。
每个业务场景必须先写失败测试,再写最小实现。

第六阶段,失败时用 systematic-debugging

不要让 AI 一看到失败就乱改。比如测试报“库存数量不一致”,可能是事务没提交,可能是测试数据错了,也可能是业务口径错了。要让它先收集证据:

1
2
3
4
5
6
7
8
9
10
请使用 systematic-debugging skill 分析当前失败测试。
不要直接改代码。

请输出:
1. 失败测试名称;
2. 期望值和实际值;
3. 相关日志;
4. 可能根因;
5. 还需要查看哪些文件;
6. 最小修复方案。

第七阶段,每个切片后都做 requesting-code-review

1
2
3
4
5
6
7
8
9
请使用 requesting-code-review skill 审查当前 diff。
重点看:
1. 是否符合 OpenSpec 的 proposal/design/tasks/specs;
2. 是否只修改了本切片范围;
3. 事务边界是否正确;
4. 幂等记录是否和业务写入一致;
5. 并发场景是否可能重复处理差异;
6. 报表口径是否和 specs 一致;
7. 测试是否覆盖异常和回滚。

这一轮 review 要敢于阻塞。如果出现新依赖、无关重构、状态机绕过、没有测试的核心逻辑,就应该停下来修正。

第八阶段,完成后 /opsx:verify/opsx:sync/opsx:archive

1
/opsx:verify purchase-receipt-discrepancy

先确认实现符合 specs。然后:

1
2
3
4
5
6
7
请使用 verification-before-completion skill 做完成前检查。
列出:
1. 已完成的验收标准;
2. 已运行的测试;
3. 未自动化覆盖的人工验收点;
4. 剩余风险;
5. 是否可以 sync 和 archive。

确认后再执行:

1
2
/opsx:sync purchase-receipt-discrepancy
/opsx:archive purchase-receipt-discrepancy

最后可以用:

1
2
请使用 finishing-a-development-branch skill 收尾。
整理变更摘要、测试结果、风险说明和后续维护建议。

Java 大需求的切片原则

对 Java 后端来说,大需求切片不能只按“前端页面、后端接口、数据库”这种粗粒度拆。更好的方式是按可验收业务能力拆。

状态先行。先把枚举、状态机、允许操作、禁止操作定义清楚。状态错了,后面所有逻辑都会错。

数据先行。表结构、唯一索引、幂等键、流水表要先设计好。尤其是库存、财务、支付这类业务,后补数据模型通常代价很高。

测试先行。每个业务切片至少有成功、失败、重复、并发、回滚这些测试或验证清单。

接口兼容。新增字段、枚举值、响应结构要考虑前端和其他服务是否受影响。

事务边界单独审。哪些操作必须同事务,哪些可以异步补偿,哪些必须写流水,需要在 design 阶段写清楚。

报表口径单独审。大需求经常影响统计,不要等上线后才发现报表数字对不上。

每个切片都能回滚。数据库字段、消息消费、定时任务、缓存更新都要考虑灰度和回退。

供应链案例:采购到货差异处理

这个需求可以拆成三个阶段。

第一阶段,只做差异可记录。

范围包括:差异类型、差异单、差异明细、登记到货时生成差异记录。这个阶段不直接影响财务,只保证业务事实能记录。

适合的指令:

1
2
3
/opsx:propose purchase-receipt-discrepancy-recording
请使用 brainstorming skill 澄清差异类型和状态。
请使用 writing-plans skill 把记录差异拆成小任务。

第二阶段,做库存影响。

范围包括:合格品入库、不合格品进入待处理区、多到数量是否允许入库、少到是否保留待到货数量。

适合的指令:

1
2
请使用 test-driven-development skill 实现库存影响。
先写少到、多到、不合格、重复登记、并发登记的测试。

第三阶段,做财务和报表。

范围包括:暂估数量、应付数量、差异率、不合格率、供应商履约统计。

适合的指令:

1
2
请使用 requesting-code-review skill 审查财务暂估和报表口径。
重点检查历史数据兼容、SQL 性能、分页导出、租户和数据权限。

这样拆的好处是,每个阶段都有业务价值,也都有明确边界。第一阶段即使先上线,也不会破坏库存和财务;第二阶段上线后库存闭环;第三阶段再补齐统计和经营分析。

组合使用的边界与风险

第一个坑,是还在探索需求时就 /opsx:apply。大需求前期应该多用 /opsx:explorebrainstorming/opsx:propose,不要急着写代码。

第二个坑,是只写 OpenSpec,不用 Superpowers 审。proposal 看起来完整,不代表任务可执行。一定要用 requesting-code-reviewwriting-plans 去审 artifacts。

第三个坑,是 Superpowers 只说不用点名。不要写“请使用 superpowers 帮我处理”,要写“请使用 systematic-debugging skill”或“请使用 test-driven-development skill”。

第四个坑,是任务切片太大。凡是一个任务里同时出现 Controller、Service、Mapper、表结构、消息、报表、测试,基本都应该继续拆。

第五个坑,是没有完成前验证。大需求最后必须用 /opsx:verifyverification-before-completion 兜底,确认不是“代码写完了”,而是“需求真的完成了”。

总结

OpenSpec/OPSX 和 Superpowers 组合起来,真正解决的是大需求的两个问题:规格不清和执行失控。

OpenSpec 用 /opsx:propose/opsx:apply/opsx:verify/opsx:sync/opsx:archive 管住变更生命周期。Superpowers 用 brainstormingwriting-planstest-driven-developmentsystematic-debuggingrequesting-code-reviewverification-before-completion 管住开发过程。

对 Java 系统来说,这套组合特别适合订单、库存、采购、财务、报表、权限、消息消费这类跨模块需求。AI 可以写代码,但大需求要先有规格,再有计划,再有测试和审查。否则速度越快,风险越大。

参考资料