Vibe Coding 最容易遇到的瓶颈,并不是 AI 不会写代码,而是每次开始一个新任务,都好像要重新教 AI 一遍如何工作。
项目一多,问题就会逐渐显现:
- 每个项目都有自己的规则,但 AI 不一定知道应该先读什么。
- 写过的脚本、解决过的问题,下次遇到类似需求仍然需要重新摸索。
- 有些 AI Agent 已经定义好了,却没有形成统一的调用和协作机制。
- 有些工作流明明重复执行过很多次,却始终停留在临时提示词阶段。
- AI 能够完成代码修改,却不一定知道如何验证修改是否正确。
- 每次开启新对话,都需要重新解释项目背景、技术约束和过去的决策。
这些问题单独看都不严重,但叠加起来,就会产生一种奇怪的现象:
AI 的能力越来越强,人却越来越忙于管理 AI。
我希望解决的正是这个问题。
经过一系列实践,我逐渐形成了一套思路:不再把 AI 编程理解为人与 AI 之间的一次次对话,而是将其设计成一套有组织结构、有专业分工、有执行标准、有验证机制,并且能够从实际工作中持续改进的操作系统。
这篇文章记录的就是这套方法论。
一、重新定义 Vibe Coding:从提示词驱动转向工作流驱动
最初使用 AI 编程时,我的主要工作是描述需求、补充上下文、检查代码、指出错误,然后让 AI 继续修改。
这种方式在小项目中很好用,但项目数量和复杂度增加后,会出现三个问题。
第一,经验无法自动复用。
某个项目已经解决过的构建问题、部署问题或数据校验问题,不会因为另一个项目遇到类似问题,就自动转化为可调用的能力。
第二,执行过程缺乏稳定性。
同一个任务,今天的 AI 可能会先检查项目规则,明天却直接开始修改代码。它可能使用已有脚本,也可能重新写一套功能相同的脚本。
第三,用户承担了过多的协调工作。
本来应该由 AI 判断的事情,例如应该调用什么工具、是否需要独立审查、应该运行什么测试,却需要用户不断提醒。
我认为,解决这些问题的关键是改变人和 AI 的分工。
过去:
用户提出需求 → 用户解释背景 → 用户指定步骤 → AI 执行 → 用户检查 → 用户指出问题 → AI 修复。
我希望形成的新模式是:
用户提出目标和边界 → AI 理解环境 → AI 制定执行方案 → AI 调用合适的能力 → AI 执行与验证 → AI 交付结果 → 有价值的经验进入下一轮工作流。
这里有一个重要区别:
用户负责定义做什么、为什么做,以及哪些事情不能做;AI 负责研究如何做,并对执行过程和交付质量负责。
这并不意味着 AI 获得无限权限。恰恰相反,越希望 AI 自主执行,就越需要清楚地定义它的权限边界。
二、先建立分层治理,而不是把所有规则塞进一个文件
我最先意识到的问题,是 AI 缺少稳定的长期工作上下文。
如果每次都依靠用户在对话中重复说明规则,那么项目越多,沟通成本就越高。
因此,我选择建立分层的指令体系。
1. 全局层:定义 AI 的通用工作方式
全局规则应该回答:
- 用户与 AI 分别承担什么责任?
- AI 应该如何理解任务?
- 如何保护已有工作?
- 什么情况下需要先制定计划?
- 什么情况下可以委派子任务?
- 哪些操作必须获得用户授权?
- 交付时需要提供什么证据?
例如:
AI 可以自行决定采用哪种测试方式,但不能因为认为提交代码更方便,就擅自执行 Git Commit。
AI 可以自行检查项目中的相关文件,但不能随意覆盖用户尚未提交的修改。
全局规则的作用不是告诉 AI 如何完成每一种具体任务,而是建立所有项目共同遵守的行为准则。
2. 工作区层:建立跨项目协作标准
当多个项目位于同一个工作区时,还需要一层更高的组织规则。
这一层主要负责:
- 哪些项目正在维护?
- 每个项目的职责是什么?
- 哪些项目之间存在依赖关系?
- 哪些能力可以共享?
- 哪些文件由哪个项目维护?
- 跨项目任务应该如何划分范围?
这里最重要的是明确权属。
例如,一个项目负责生成产品,另一个项目负责维护生成后的产品。
两者可以共享通用开发规范,但不能因为存在上下游关系,就让下游产品继承上游所有内部实现细节。
3. 项目层:描述具体项目的真实情况
每个项目都应该有自己的入口文件,通常是 AGENTS.md。
它需要告诉 AI:
- 这个项目是什么?
- 使用什么技术架构?
- 核心文件在哪里?
- 哪些模块由本项目负责?
- 有哪些不能触碰的边界?
- 应该从哪里开始检查?
- 应该运行什么命令进行验证?
- 如何完成最终交付?
项目级指令不应该成为整个项目的百科全书。
详细架构、技术决策、历史记录和操作手册应该放在各自的知识文档中,需要时再读取。
4. 模块层:只在确有必要时继续细分
如果一个项目包含多个具有独立职责、独立约束和独立验收方式的模块,可以继续建立模块级指令。
但不是每个文件夹都需要一份 AGENTS.md。
我采用的原则是:
治理结构应该反映真实的责任边界,而不是为了目录整齐而制造层级。
最终形成的逻辑是:
全局规则负责行为,工作区规则负责协作,项目规则负责项目本身,模块规则负责独立模块。
这样既能保证统一性,又不会让简单项目承担复杂项目的维护成本。
三、让不同的 AI 原生能力各司其职
建立分层指令之后,接下来需要解决的是能力组织问题。
我逐渐意识到,AGENTS、Skills、Subagents、Scripts、Hooks 等机制并不是可以互相替代的东西。
它们应该承担不同职责。
1. AGENTS.md:告诉 AI 应该如何工作
AGENTS.md 是长期规则的载体。
它适合存放:
- 项目身份和职责。
- 行为约束。
- 重要技术边界。
- 工作流程入口。
- 验收要求。
- 其他知识文档和能力的引用方式。
它不适合存放:
- 每次任务都不会用到的详细技术手册。
- 大量重复的操作步骤。
- 所有历史执行记录。
- 与当前项目无关的其他项目知识。
一个重要原则是:AGENTS.md 应该尽量短,但不能缺少真正影响 AI 行为的规则。
2. Skills:把成熟的工作流程封装起来
如果某种工作需要重复执行,而且包含明确的判断逻辑、操作步骤和验收要求,就可以考虑将其封装为 Skill。
例如:
- 对代码修改进行专项审查。
- 批量检查内容质量。
- 执行特定类型的数据分析。
- 完成某种产品的构建和交付。
- 对特定技术问题进行标准化排查。
一个 Skill 不应该只是一个很长的提示词。
它至少需要明确:
- 什么情况下应该触发?
- 什么情况下不应该触发?
- 需要读取什么输入?
- 应该按照什么步骤执行?
- 需要调用哪些工具或脚本?
- 最终应该产生什么结果?
- 如何判断执行成功?
Skill 的名称和 description 负责让 AI 发现它,主体文件描述工作流程,references 保存需要时才读取的详细知识,scripts 负责其中可确定性执行的部分。
这样可以避免每次执行任务都加载大量无关上下文。
3. Subagents:把真正独立的工作委派出去
Subagent 解决的是专业分工问题。
主 Agent 可以担任任务负责人,其他 Agent 承担独立的研究、测试、审查或专项执行任务。
但我不认为 Agent 越多越好。
我采用的判断标准是:
- 任务是否可以独立完成?
- 是否有明确的输入和输出?
- 是否有独立的工作范围?
- 是否可以避免与其他 Agent 修改同一批文件?
- 最终结果是否能够被主 Agent 整合和验证?
如果答案是否定的,就没有必要委派。
例如,一个任务可以让一个 Agent 只读分析现有架构,另一个 Agent 检查独立的测试覆盖情况,而主 Agent 负责最终实施和整合。
但如果两个 Agent 都需要修改同一个核心数据结构,并行工作反而可能制造更多冲突。
因此,我更倾向于:
默认单 Agent,必要时委派一个专家,只有真正独立的任务才并行。
主 Agent 始终对最终结果负责,不能把子 Agent 的报告直接当作已经验收的成果。
4. Scripts:让确定性的工作交给程序
对于输入明确、步骤固定、输出可以验证的工作,应该优先使用脚本。
例如:
- 文件检查。
- 数据格式转换。
- 批量校验。
- 测试执行。
- 构建检查。
- 文件差异比较。
这些事情不需要每次都让大模型重新推理一遍。
脚本负责确定性,AI 负责理解任务、选择脚本、解释异常和处理非标准情况。
这也意味着,不应该把所有脚本都改造成 Skill。
脚本本身可能已经是最合适的工具。只有当脚本需要被某种可复用的条件式工作流程组织起来时,才有必要增加 Skill。
5. Hooks、Rules、Config 和 MCP:处理自动化与运行环境
这些机制也有各自的边界:
| 机制 | 主要职责 |
|---|---|
| Hooks | 在特定生命周期事件发生时执行自动化动作 |
| Rules | 对命令执行等行为施加规则约束 |
| Config | 管理运行模式、环境和权限配置 |
| MCP / Plugins | 为 AI 提供外部系统和专业工具的访问能力 |
它们不是为了让架构看起来更先进而存在的。
只有在存在明确需求、收益大于维护成本时,才应该引入。
例如,一个检查动作如果每天频繁执行、完全可以由脚本完成,就不一定需要再引入 Hook。
一个项目如果没有外部数据访问需求,也不需要为了完整性安装 MCP。
6. Goals:管理长期、跨阶段的任务
对于复杂任务,仅靠一条提示词往往不够。
这时需要使用 Goal,将任务目标、背景、约束、阶段、验收条件和停止条件固定下来。
Goal 管理的是一个持续推进的工作目标,而不是简单地把一段提示词保存起来。
它尤其适合:
- 多阶段架构改造。
- 大规模项目迁移。
- 多模块协作。
- 长期研究和实施。
- 需要阶段性交付和持续跟踪的任务。
重要的是,Goal 应该定义最终要达到什么状态,而不是把每一个操作步骤都写死。
具体执行路线应该尽可能由 Codex 根据实际环境判断。
四、设计一套标准执行闭环
有了上述基础设施,还需要解决一个更重要的问题:
AI 每次接到任务之后,究竟应该如何工作?
我将其归纳为八个阶段。
第一步:理解目标
首先识别用户真正想解决的问题。
不能只理解字面上的功能需求,还要理解:
- 为什么需要这个功能?
- 它解决什么实际问题?
- 影响哪些模块?
- 什么结果才算真正完成?
如果目标本身不清楚,应该先澄清,而不是急着写代码。
第二步:检查当前环境
在修改任何东西之前,先检查项目现状。
包括:
- 项目指令。
- 相关架构文档。
- 当前代码实现。
- 已有工具和脚本。
- Git 工作区状态。
- 现有未提交修改。
- 任务涉及的依赖关系。
这一步非常重要。
AI 不能假设以前的报告仍然代表当前项目状态,也不能因为某个文件看起来可以修改,就直接覆盖它。
第三步:制定适度的计划
不是每个任务都需要长篇计划。
小型、低风险任务可以直接执行。
复杂任务、跨模块任务和高风险任务,则应该先形成可审查的计划。
计划至少需要说明:
- 目标。
- 影响范围。
- 实施方案。
- 依赖关系。
- 风险。
- 验收方式。
如果任务非常复杂,还可以进一步拆分为多个阶段。
这里有一个原则:计划的复杂程度应该与任务的复杂程度相匹配。
第四步:选择执行能力
Codex 根据任务判断:
- 是否需要调用 Skill?
- 是否需要执行已有脚本?
- 是否需要委派 Subagent?
- 是否需要查询外部资料?
- 是否需要使用某种连接器?
- 是否需要进行额外的权限确认?
用户不应该每次都指定这些内部操作。
这正是建设工作流的目的:让 AI 能够根据任务自行选择最合适的工具组合。
第五步:实施任务
执行时优先采用最小且完整的修改。
避免为了完成一个小功能,顺手重构大量无关代码。
对于复杂任务,按照已经批准的计划逐阶段实施。
如果实际情况与原计划不符,应该先重新评估,而不是机械地继续执行。
第六步:验证结果
这是整个工作流中最容易被低估的环节。
代码修改完成,不等于任务完成。
必须根据实际修改选择适当的验证方式:
- 静态检查。
- 单元测试。
- 集成测试。
- 构建验证。
- 浏览器或实际运行验证。
- 必要的人工 QA。
不同的验证方式证明不同的事情。
例如,TypeScript 检查通过,只能说明相应的类型检查没有发现问题,并不能证明整个产品的用户体验正常。
构建成功,也不意味着部署后的实际行为一定正确。
第七步:审查和整合
对于重要修改,应当检查:
- 实际 Diff。
- 是否产生非预期修改。
- 是否破坏已有功能。
- 是否存在遗漏的测试。
- 是否符合原始需求。
- 是否需要独立审查。
如果使用了 Subagents,主 Agent 还需要检查它们的结果,并负责最终整合。
第八步:交付和状态更新
最终交付不应该只说一句“已经完成”。
至少要说明:
- 完成了什么。
- 修改了什么。
- 实际运行了哪些验证。
- 哪些测试通过。
- 哪些项目没有验证。
- 还有什么风险。
- 是否需要用户进行下一步操作。
只有这样,用户才能判断结果是否值得接受。
五、如何写出高质量的 Codex Goal?
我认为,Goal 的质量很大程度上决定了复杂任务的执行质量。
很多人会写:
帮我优化整个项目,让它更规范、更高效。
这种描述缺少真正可执行的信息。
AI 虽然可以自行发挥,但很难判断什么才是用户认可的最终状态。
我现在更倾向于按照以下结构组织 Goal。
| 组成部分 | 应该回答的问题 |
|---|---|
| Goal | 最终要实现什么? |
| Context | 为什么要做?目前是什么情况? |
| Scope | 哪些项目、模块和文件属于任务范围? |
| Inputs | AI 应该检查哪些现有资料? |
| Constraints | 有哪些不可违反的限制? |
| Exclusions | 哪些事情明确不做? |
| Acceptance Criteria | 如何判断任务真正完成? |
| Evidence | 需要提供哪些实际执行证据? |
| Deliverables | 最终应该交付什么? |
| Stop Conditions | 什么情况下应该停止并等待用户决策? |
举个通用例子。
假设需要优化一个产品的自动化测试体系。
与其要求 AI 按照某个预想目录创建十几个文件,不如明确:
- 目标:提高测试的可重复性和覆盖质量。
- 背景:现有测试存在重复、遗漏和难以定位的问题。
- 范围:仅检查指定项目的测试体系。
- 约束:保护现有用户修改,不修改无关业务代码。
- 验收:真实执行代表性测试,验证正向、负向和边界情况。
- 交付:输出发现的问题、最小整改方案、测试证据和遗留风险。
- 停止条件:任何涉及扩大权限或改变生产环境的操作都需要批准。
至于具体应该采用什么测试框架、是否需要脚本、如何组织测试文件,则交给 AI 根据现有架构决定。
高质量 Goal 的本质,是把决策边界交代清楚,而不是把执行细节全部替 AI 决定。
六、如何避免多 Agent 协作变成新的管理负担?
多 Agent 是一种生产力工具,但它也会引入新的成本:
- 上下文重复。
- 任务拆分成本。
- 沟通和交接成本。
- 结果冲突。
- 最终整合成本。
- 额外 Token 消耗。
因此,我更倾向于把 Agent 理解为专业岗位,而不是可以无限增加的虚拟员工。
一个合理的协作体系应该包含:
主 Agent:
负责理解目标、任务拆解、资源调度、范围控制、结果整合和最终验收。
专业 Agent:
负责边界明确的独立任务,例如专项研究、代码审查、安全检查或测试分析。
主 Agent 需要给每个子任务明确:
- 任务目标。
- 必要上下文。
- 允许读取的范围。
- 允许修改的范围。
- 需要返回的结果。
- 验收标准。
尤其要注意,不能让多个 Agent 同时修改同一个核心模块,却期待它们自然协调。
一个任务如果必须依赖另一个任务的结果,就应该考虑串行执行,而不是为了并行而并行。
最终,主 Agent 必须对整个任务的完成质量负责。
七、真正可靠的 QA:计划不等于执行,执行不等于验证
这是我在实践中越来越重视的一点。
AI 很容易给出一份看起来非常完整的执行报告,但报告写得完整,不代表所有事情都真的发生过。
因此,我要求工作流严格区分三种东西:
第一,计划。
计划说明准备做什么。
第二,执行记录。
执行记录说明实际运行了什么命令、调用了什么工具、产生了什么变化。
第三,验证证据。
验证证据说明实际结果是否满足预期。
三者不能互相替代。
我还倾向于使用明确的状态标识:
| 状态 | 含义 |
|---|---|
| PASS | 已执行,并且验证符合预期 |
| GAP | 已发现实际缺陷或不满足项 |
| NOT VERIFIED | 缺少足够证据,无法确认 |
| NOT APPLICABLE | 该检查不适用于当前任务 |
例如,子 Agent 因为用量限制没有完成结果回传,就不能写成协作机制已经通过验证。
同样,某个项目的构建命令没有运行,也不能因为静态代码看起来正确就标记构建通过。
还需要区分不同操作的副作用
我会特别区分:
- 只读检查。
- 本地验证。
- 构建和生成产物。
- 集成测试。
- 外部服务写入。
- 生产部署。
这些操作的风险并不相同。
例如,本地构建可能会清理并重新生成输出目录;部署则可能直接改变外部用户看到的内容。
AI 应该在执行前理解这些副作用,并遵循相应的授权边界。
默认保护已有修改,不擅自提交、推送、部署或改变外部状态。
真正成熟的 AI 工作流,不仅要知道怎样完成任务,还必须知道自己正在改变什么。
八、跨项目复用:统一标准,而不是强行统一结构
当 AI 开始同时服务多个项目时,另一个问题就会出现:
哪些能力应该共享?哪些应该保留在项目内部?
我的答案是:
统一治理原则,不统一所有项目的具体结构。
不同项目可能有完全不同的技术栈、业务特点和维护需求。
一个内容型项目可能需要文章检查 Skill。
一个数据型工具可能需要数据验证脚本。
一个独立产品可能只需要一份简洁的 AGENTS.md 和一套构建检查命令。
没有必要为了保持目录一致,就让每个项目都拥有相同数量的 Agent、Skills 和 Scripts。
我更认可一个渐进式原则:
先在实际使用它的项目中解决问题,等第二个真实使用场景出现,再考虑抽象成共享能力。
例如,某个脚本第一次出现时,可以直接留在项目内部。
当另一个项目也出现相同需求,并且两者的输入、输出和执行逻辑确实一致时,再考虑提取公共能力。
同时,必须明确唯一维护源。
共享能力可以分发到多个项目,但不能出现多个互相修改、互相冲突的版本。
对于产品工厂和生成产品,还需要特别区分:
- 工厂负责通用生成规则、模板和验收协议。
- 成品负责自己的业务代码、产品规则和维护方式。
成品可以继承通用能力,但应该保持独立运行和维护的能力。
这既减少重复建设,也避免上下游形成不必要的耦合。
九、让工作流具备自我进化能力
到这里,工作流已经可以重复执行任务。
但我希望进一步解决一个问题:
如果 AI 在执行过程中发现现有规则有问题,下一次它能不能自动变得更好?
例如:
- 用户多次指出同一个错误。
- 某个 Skill 经常没有被正确调用。
- 某个测试脚本反复出现相同故障。
- 某条指令让 AI 频繁读取无关上下文。
- 某个工作流程已经重复成功,并且收益明确。
- 项目架构变化,导致旧规则不再适用。
如果这些经验只停留在聊天记录中,就没有形成真正的长期改进。
因此,我将自进化设计成一个受控闭环。
第一步:发现问题或机会
从实际任务中收集证据。
但不是每次失败都值得修改规则,也不是每次成功都需要创建一个新 Skill。
一次性错误应该优先在当前任务中解决。
只有当问题具有持续性,或者某种工作方式已经证明值得复用时,才考虑进入治理流程。
第二步:确定应该修改哪一层
不同问题应该由不同资产负责。
| 问题类型 | 优先改进对象 |
|---|---|
| 长期行为规则不正确 | AGENTS.md |
| 可重复工作流程不完善 | Skill |
| 确定性操作存在问题 | Script |
| 专业岗位职责不清楚 | Subagent |
| 缺少回归检测 | Eval / Test |
| 技术知识过时 | Reference / Knowledge |
不要为了修复一个 Skill 的问题,就修改整个工作区的全局指令。
应该选择能够解决问题的最小范围。
第三步:先形成证据和提案
正式修改前,需要明确:
- 原来的行为是什么?
- 实际问题在哪里?
- 为什么现有机制没有解决?
- 最小修改是什么?
- 修改后能带来什么收益?
- 是否可能产生新的问题?
- 如何验证?
- 如何回滚?
最好准备正向、负向和边界测试。
例如,某个 Skill 应该在特定任务中触发,但不应该在普通任务中触发,那么两种场景都应该测试。
否则可能只是解决了漏触发,却造成了过度触发。
第四步:经过审批再修改正式规则
自进化不等于 AI 可以随意修改自己的制度。
我更认可:
观察 → 证据 → 分类 → 精确提案 → 用户批准 → 正式修改 → 回归验证 → 记录结果。
批准应该对应具体修改内容,而不是笼统地允许 AI 今后自行优化所有规则。
修改完成后,还要验证实际安装的文件和运行行为,而不只是检查源文件。
第五步:持续学习,但不要持续折腾
还有一个重要区别:
真正的自进化应该由实际事件驱动,而不是要求 AI 每天重新检查全部规则。
例如,某个客户端发生了与 Skill 发现机制有关的变化,就应该定向验证 Skill 的发现和调用行为。
如果只是无关紧要的版本变化,就没有必要重新审查所有项目。
即使版本号没有变化,如果官方发布了相关能力更新,也可能值得重新验证。
版本信息只是信号,实际行为才是判断依据。
自进化的目标是让未来的任务越来越顺利,而不是让 AI 永远忙于修改自己的工作流。
十、最容易犯的错误:把工作流建设本身变成一个无底洞
在实践过程中,我逐渐认识到,建设 AI 工作流也存在明显的过度工程化风险。
以下做法看起来很专业,但不一定真正提高效率。
1. 为了标准化而创建大量文件
不是每个项目都需要 Agent、Skill、Hook、Rules 和 MCP。
如果一个简单项目只需要一份 AGENTS.md 和几个测试脚本,就不应该人为增加复杂度。
2. 把所有重复操作都做成 Skill
脚本、Skill 和 Agent 不是同一种东西。
确定性任务用脚本,条件式专业流程用 Skill,独立专业职责才用 Agent。
3. 为了并行而并行
如果任务本身无法拆分,增加 Agent 只会提高沟通成本。
4. 把审计报告当成实际能力
发现某个 Skill 文件存在,不代表 AI 能够正确发现它。
确认 Skill 能被发现,也不代表 AI 能在正确的任务中调用它。
即使成功调用,也不代表它真正完成了预期工作。
必须区分文件存在、能力可发现、正确调用、成功执行和结果验收。
5. 反复审计已经完成的事情
治理体系应该有明确的完成条件。
当基础架构已经建立,关键能力已经得到验证,就应该冻结结构,转向正常产品开发。
只有出现新的实际问题、长期用户纠正、重要架构变化或值得复用的新经验时,才重新进入演进流程。
不能让 AI 工作流的维护工作量不断超过它所节省的工作量。
十一、如果从零开始,我会按照什么顺序建设?
如果现在从一个全新的多项目工作区开始,我会采用以下顺序。
阶段一:摸清现状
先盘点项目、目录、Git 状态、已有 Agent、Skills、脚本、测试和文档。
不要急着修改。
先回答:
- 哪些项目是真正需要长期维护的?
- 哪些项目已经废弃?
- 哪些能力已经存在?
- 哪些能力存在重复?
- 哪些工作流程存在明显缺口?
阶段二:建立分层治理
先建立个人级、工作区级和项目级指令。
明确每一层的职责、继承关系和维护权属。
先解决 AI 不知道应该听什么规则的问题。
阶段三:整理专业能力
盘点已有的 Agent、Skills 和 Scripts。
将成熟的重复流程封装成 Skills。
将确定性操作保留为脚本。
将真正独立的专业职责配置为 Subagents。
不为了目录完整而增加新资产。
阶段四:用真实任务验证
不要只做静态文件检查。
选择不同类型的真实任务,观察 AI 是否:
- 正确读取项目规则。
- 找到相关 Skill。
- 使用现有脚本。
- 在适当情况下委派子任务。
- 正确执行测试。
- 保护原有修改。
- 提供真实的交付证据。
阶段五:建立受控自进化机制
将重复出现的问题和成熟的工作经验沉淀下来。
每次只修改真正需要改进的部分。
保留基线、精确 Diff、回归测试、审批和回滚能力。
阶段六:冻结基础架构,进入日常生产
当关键能力已经得到验证,就不再无休止地重构治理体系。
后续让真实开发任务驱动改进。
这才是一个可持续的工作流。
十二、最终目标:让 AI 成为一个能够持续进化的开发操作系统
我对 AI Vibe Coding 的期待,已经从最初的自动生成代码,转变为一套完整的生产体系。
它应该具备:
- 理解能力:知道自己正在维护什么,以及为什么这样维护。
- 组织能力:能够拆解任务,选择合适的专业能力。
- 执行能力:能够调用工具、脚本和专业 Agent 完成工作。
- 验证能力:能够通过实际证据判断结果是否正确。
- 记忆能力:能够保留真正有价值的规则、知识和历史决策。
- 复用能力:能够在多个项目之间共享成熟经验。
- 进化能力:能够识别持续存在的问题,并提出经过验证的改进方案。
而人应该逐渐从日常执行细节中抽离出来。
我不希望每次开发都要亲自告诉 AI 应该先读哪个文件、调用哪个 Agent、运行哪个脚本、检查哪个测试。
这些事情应该成为 AI 工作系统自身的职责。
我只需要持续明确目标、提供必要的业务判断、处理需要人工决策的事项,并对最终结果进行验收。
这套体系真正成熟的标志,不是拥有多少个 Agent、多少份 Skill 或多少个自动化脚本。
而是当我提出一个新的目标时,AI 能够准确理解它,在正确的边界内自主组织工作,调用已有能力,完成执行和验证,并在必要时将经验沉淀为下一次可以复用的能力。
Vibe Coding 的下一阶段,不应该是人类写出越来越复杂的提示词,而是让 AI 拥有一套越来越成熟的工作系统。
我认为,这才是从 AI 辅助编程走向 AI 原生开发的真正转变。




