芥末
发布于 2026-04-09 / 0 阅读
0
0

SDD-RIPER 团队落地指南:用 Spec 和阶段门禁管住大模型编程

单人尝试大模型编程时,很多问题可以靠经验兜住:多追问几轮、多看几次 diff、发现模型跑偏就手动拉回来。但团队推广时,靠个人手感很快会失效。

常见风险集中在四类:

痛点典型表现根因
上下文腐烂对话越长,模型越容易忘掉前面说过的边界,甚至把之前改好的逻辑改回去任务约束只存在聊天记录里,没有稳定的真相源
审查瘫痪模型一次生成几百行代码,人来不及逐行 Review生成速度超过人工审查速度
维护断层两周后没人知道某段 AI 代码为什么这么写,不敢改也不敢删决策过程没有沉淀
代码不信任不知道模型依据什么做改动,上线前没有把握缺少可验证、可追溯的工程机制

SDD-RIPER 的核心价值,是把“跟 AI 聊天写代码”改造成“有文档、有阶段、有审批、有回溯的工程流程”。

  • SDD(Spec-Driven Development,规格驱动开发):用 Spec 保存需求、边界、约束、风险、方案、计划、执行记录和验收结果。
  • RIPER:把大模型执行过程拆成 Research、Innovate、Plan、Execute、Review 五个阶段,并用审批门禁限制模型什么时候能写代码。
  • CodeMap:项目或功能级代码地图,帮助人和模型快速找到入口、链路、依赖和风险点。
  • ProjectMap:多项目协作地图,描述多个仓库之间的职责、接口和数据流。

一句话概括:

代码生成不是最贵的,稳定上下文才是最贵的。
Code is Cheap, Context is Expensive.

整体架构:Spec 管记录,RIPER 管流程,CodeMap 管导航

SDD-RIPER 不要求模型一次性理解整个项目,也不鼓励把所有代码塞进上下文窗口。更稳的方式是把信息分层:任务级信息进入 Spec,项目级导航进入 CodeMap,跨项目关系进入 ProjectMap。

flowchart TD
    A[需求输入<br/>PRD / 讨论记录 / Bug 描述] --> B[Context Bundle<br/>结构化上下文包]
    C[代码仓库] --> D[CodeMap<br/>项目或功能代码地图]
    E[多仓库工程] --> F[ProjectMap<br/>跨项目导航]

    B --> G[Spec<br/>任务真相源]
    D --> G
    F --> G

    G --> H[RIPER 状态机]
    H --> I[Research<br/>事实锁定]
    I --> J[Innovate<br/>方案对比]
    J --> K[Plan<br/>原子级计划]
    K --> L{Plan Approved?}
    L -- 否 --> K
    L -- 是 --> M[Execute<br/>按计划写代码]
    M --> N[Review<br/>Spec vs Code 验收]
    N --> O{通过?}
    O -- 否 --> K
    O -- 是 --> P[Archive<br/>归档为长期资产]

这张流程图里有两个关键点。

第一个关键点是 Plan Approved 才能进入 Execute。未批准的计划不能写代码,这是团队推广时最小、最硬的一条规则。

第二个关键点是 Review 不通过要回到 Plan。如果执行过程中发现方案本身有问题,不应该让模型一边写一边“顺手优化”,而是停下来重新规划、重新审批。

Spec 首要服务对象是人,不只是大模型

很多人会把 Spec 理解成“喂给模型的提示词”。这个理解太窄了。Spec 对大模型确实有帮助,但它更重要的作用是把团队协作中的隐性知识变成显性资产。

受益者Spec 解决的问题没有 Spec 的代价
开发者自己半年没碰的模块,读 Spec 就能恢复任务背景和决策过程重新翻代码、猜逻辑、踩旧坑
接手同事交接从口头同步变成“读 Spec + 按计划施工”接手周期长,风险靠经验兜底
TL / 主管能看到需求状态、已确认决策、风险和待办进度靠口头汇报,风险靠事后暴露
团队质量每次改动都有方案、审批、执行和验收记录只能从 commit message 里猜原因
组织知识资产人员轮换时知识不跟着人流失核心成员离开后项目变黑盒

大语言模型(LLM,Large Language Model)从 Spec 中获得的是注意力边界:它知道这次任务要做什么、不做什么、哪些风险不能碰、验收标准是什么。人从 Spec 中获得的是工程真相源:谁做过什么决策,为什么这样做,执行到了哪里。

所以,SDD-RIPER 不是把 Spec 当作模型的常驻“操作系统”,而是把 Spec 当作可按需读取的任务档案。模型只在切阶段、验收、排障、冲突处理时读取相关段落,不需要每一轮对话都把完整文档灌进去。

复杂项目更需要 CodeMap 和 ProjectMap

项目小、链路短、只有一两个人维护时,临时对话和直接扫代码还能勉强推进。一旦进入多服务、多前端、多仓库、多团队协作的场景,临时上下文很容易失控。

复杂工程里的真正难点通常不是“代码太多”,而是三件事没有工程化:

  • 没有稳定边界:不知道这次任务到底改到哪里为止。
  • 没有统一索引:每次都重新扫仓、重新认路、重新猜调用链。
  • 没有协作真相源:人和模型都依赖临时聊天上下文推进。

更合理的上下文分层如下:

层级作用适用范围
Spec描述单个任务的目标、范围、约束、风险、方案、计划和验收任务级
CodeMap描述单个项目内部的入口、模块、调用链、依赖、风险点项目级
ProjectMap描述多个项目之间的职责、接口契约、数据流和修改范围工程级

复杂工程的正确姿势不是让模型读更多代码,而是让模型先找到正确索引,再按需进入局部代码。

三种常见协作模式

模式workdir 建议处理方式
一个主项目 + 若干轻项目主项目目录主项目内工作,通过 ProjectMap 暴露轻项目中与任务相关的目录、接口、配置或页面
两个主项目并行协作两个项目的父目录父目录维护跨项目总 Spec,每个项目内部保留自己的 CodeMap
多个项目组成复杂工程工程根目录或专门的协作文档目录先读 ProjectMap,锁定涉及项目,再进入各项目 CodeMap,最后按需读代码

多项目协作可以按这个顺序推进:

flowchart LR
    A[ProjectMap<br/>锁定项目范围] --> B[相关项目列表]
    B --> C[项目 A CodeMap]
    B --> D[项目 B CodeMap]
    B --> E[项目 C CodeMap]
    C --> F[按需阅读具体代码]
    D --> F
    E --> F
    F --> G[回写 Spec]

即使未来上下文窗口更大,CodeMap 和 ProjectMap 仍然有价值。它们不只是为了节省 token,更是为了给团队建立统一导航、给 Review 限定范围、给长期维护沉淀资产。

质量保障:不要信任模型,要信任机制

团队不需要盲目信任大模型。大模型可以写代码,但必须被机制约束。SDD-RIPER 可以拆成四层质量保障:

层级机制解决的问题
任务边界层Spec 写清目标、范围、约束、风险和验收标准防止模型扩散改动范围
事实锁定层Research 要求每个结论都有代码出处防止模型凭经验瞎猜
审批门禁层Plan Approved 才能 Execute防止模型先斩后奏
验收回溯层Review 对照 Spec、Plan、代码和执行日志防止文档和代码脱节

Review 阶段推荐做三轴审查:

检查轴检查内容
Spec 达成率Spec 中列出的目标行为是否全部落地
Plan-Execution Diff实际改动是否偏离批准过的 Plan
代码质量与弱点空指针、边界条件、并发问题、权限绕过、兼容性风险、测试缺口

如果发现 Bug 或实现偏差,处理顺序是 Reverse Sync:先修 Spec,把预期、风险和修复方案写清楚,再修代码。这样做能避免“代码修了,文档还停留在旧世界”的问题。

RIPER 状态机:把 AI 当成高潜力新人来带

大模型很像一个速度极快、知识面很广、但容易忘边界的新人。靠谱的协作方式不是让它自由发挥,而是给它明确阶段和门禁:

  1. 让它获取信息。
  2. 要求它总结信息。
  3. 人来决定方向。
  4. 让它补全方案细节。
  5. 批准后再让它执行。
  6. 执行完做验收。
  7. 有偏差就回到前面的阶段修正。

RIPER 把这个过程工程化。

阶段做什么关键要求
Pre-Research准备 CodeMap、Context Bundle、首版 Spec把输入材料结构化
Research扫描代码和资料,锁定事实每个结论必须有出处
Innovate产出 2~3 个方案并对比人来拍板,不让模型只给一个方案
Plan拆成原子级实施清单精确到文件路径和函数签名
Execute按批准的 Plan 写代码不允许自由发挥
Review对照 Spec 验收代码不通过就回到 Plan
Archive精简归档长期资产保留给人和模型复用

状态流转可以这样理解:

stateDiagram-v2
    [*] --> PreResearch
    PreResearch --> Research
    Research --> Innovate
    Innovate --> Plan
    Plan --> PlanReview
    PlanReview --> Plan: 审批不通过
    PlanReview --> Execute: Plan Approved
    Execute --> Review
    Review --> Plan: 验收不通过
    Review --> Archive: 验收通过
    Archive --> [*]

Token 成本:SDD 是用便宜输入换昂贵输出

很多团队担心写 Spec、做 CodeMap 会增加成本。实际成本结构通常相反:结构化输入会减少模型无效输出、重复追问和返工。

大模型调用成本可以粗略理解为:

Token 类型相对价格说明
输出 token100%模型生成的内容,通常最贵
输入 token10%提供给模型的上下文
缓存输入 token1%重复命中的上下文,例如稳定 Spec

SDD-RIPER 的策略是把需求、约束、代码事实写进结构化输入,让模型少猜、少改、少返工。输入多了一点,但输出和对话轮次会减少;Spec 和 CodeMap 还能缓存复用,同一个模块后续任务会更省。

5 分钟部署:标准流和轻量流并行

团队落地建议采用双轨制:

方案适合场景特点风险
sdd-riper-one 标准流新团队、复杂需求、跨项目任务、模型能力参差不齐阶段完整、门禁清晰、审查严格常驻协议稍重
sdd-riper-one-light 轻量流熟练团队、小任务、强模型、高频迭代micro-spec、简短 summary、自动分流对模型推理和上下文能力要求高

新团队不要一上来追求轻量。标准流能帮助成员形成共同语言:什么叫 Research 充分、什么叫 Plan 可审批、什么叫 Execute 不越界。等团队已经熟悉 RIPER,再把低风险小任务切到轻量流。

最小团队规则只需要一条:

未经 Plan Approved,不得修改代码。

这条规则落地后,团队自然会进入 RIPER 节奏。

推荐目录结构

把 SDD-RIPER 产物放在统一目录里,避免散落在对话和个人笔记中。

mydocs/
├── apis/          # 接口契约:API 定义、字段说明、兼容性约束
├── codemap/       # 代码地图:功能级 / 项目级代码索引,长期资产
├── context/       # 上下文语料:PRD、设计图、讨论记录、临时资料
└── specs/         # 任务 Spec:每个需求一份,核心资产

各目录的维护方式不同:

目录性质维护方式
mydocs/apis/接口契约接口变更时同步更新
mydocs/codemap/长期资产每次需求迭代补充,团队复用
mydocs/context/一次性语料按任务归档,不要求长期维护
mydocs/specs/核心资产每个任务持续更新到 Review 结束

Pre-Research:准备输入材料

Pre-Research 的目标是让模型开始工作前已经拥有高质量输入,而不是让它进入仓库后盲扫。

常用三个命令:

命令作用是否必须
create_codemap生成代码地图,梳理入口、链路、依赖和风险中大型任务建议做
build_context_bundle把 PRD、设计图、讨论记录整理成结构化上下文包需求复杂时建议做
sdd_bootstrap汇总输入,创建首版 Spec,启动 RIPER每个新任务建议做

create_codemap:生成代码地图

适用场景:

  • 修改不熟悉的模块。
  • 接手老项目。
  • 梳理复杂链路。
  • 多人协作前统一项目认知。

示例:

create_codemap:
  mode: feature
  scope: 用户权限模块
  goal: 梳理权限校验链路

项目级梳理可以这样写:

create_codemap:
  mode: project
  scope: order-service
  goal: 输出项目总图与主流程

一份 CodeMap 至少应该包含:

# Code Map: 权限校验模块

## Scope
权限校验的完整链路,从请求入口到最终鉴权判定。

## Entry Points
- `PermissionFilter.java:L28` — HTTP 请求拦截入口
- `RpcPermissionInterceptor.java:L15` — RPC 调用拦截入口

## Core Logic Chain
1. `PermissionFilter.doFilter()` -> `AuthService.checkAccess()`
2. `AuthService.checkAccess()` -> `PermissionDAO.queryUserPermission()`
3. `LegacyAuthAdapter.java:L33` 存在历史兼容逻辑

## Dependencies
- 数据库:`t_user_permission`
- RPC:`UserCenterService.getUserRole()`
- 缓存:Redis key `perm:{userId}:{resourceId}`

## Risks / Unknowns
- `RpcPermissionInterceptor` 的调用方不明确,可能已废弃
- `LegacyAuthAdapter` 的兼容逻辑是否需要继续保留

CodeMap 不应该追求“全项目百科”。范围越准,价值越高。第一次梳理老项目可能要花 1~2 小时,但这是一次性投入,后续所有人都能复用。

build_context_bundle:生成上下文包

当需求材料分散在 PRD、设计图、会议记录、聊天记录、历史邮件里,可以先整理成上下文包。

build_context_bundle:
  input: ./mydocs/context/raw/permission-refactor

目录里可以放:

  • PRD / 需求文档。
  • UI 设计图。
  • 关键讨论记录。
  • 历史 Spec。
  • 安全规范、接口契约、兼容性说明。

产物示例:

# Context Bundle: 权限模块重构

## Source Index
| 文件 | 类型 | 关键信息 |
|---|---|---|
| prd-v2.md | 需求文档 | 细粒度授权需求 |
| security-spec.md | 约束文档 | 权限变更必须写审计日志 |
| dingtalk-discussion.md | 讨论记录 | 第一期只做接口级,字段级放第二期 |

## Requirement Facts
- 统一权限校验入口
- 第一期支持接口级授权
- 权限变更必须写审计日志

## Constraints
- 不能影响超级管理员逻辑
- 必须兼容 `LegacyAuthAdapter` 至少 3 个月
- 鉴权延迟小于 5ms

## Open Questions
- [ ] 字段级权限第二期做,接口设计是否预留扩展?
- [ ] `LegacyAuthAdapter` 三个月后是否确定下线?

Context Bundle 是一次性语料,不必像 CodeMap 那样长期精修。它的价值是把杂乱输入压缩成模型能处理的结构。

sdd_bootstrap:启动任务 Spec

每个新任务都应该有一次启动动作。

sdd_bootstrap:
  task: 权限模块重构
  goal: 统一权限校验入口,支持接口级细粒度授权
  requirement: docs/prd/permission-v2.md
  codemap_ref: mydocs/codemap/permission-check.md
  context_ref: mydocs/context/2026-06-07_permission-refactor_context_bundle.md

首版 Spec 不需要完美,缺失信息可以用 [待确认] 标注。重点是把任务从“口头描述”变成“可持续更新的工程对象”。

Research:让模型拿证据说话

Research 阶段的目标是锁定事实,消除信息差。不能接受“通常来说”“我认为”“可能是”这种没有依据的结论。

可直接这样要求模型:

请进入 Research 阶段。基于首版 Spec,逐条核查以下事实:

1. 权限校验入口在哪里?有几个入口?
2. 当前授权逻辑如何实现?
3. 有没有历史遗留特殊处理?
4. 哪些地方可能影响兼容性?

要求:
- 每个结论必须给出文件路径、函数名和行号。
- 不确定项显式列出。
- 所有新发现回写 Spec 的 Research Findings。

合格输出应该像这样:

## Research Findings

1. 权限校验入口有 2 个:
   - `PermissionFilter.java:L28` — HTTP 请求拦截入口
   - `RpcPermissionInterceptor.java:L15` — RPC 调用拦截入口

2. 授权逻辑位于:
   - `AuthService.java:L45-L78`
   - 通过 `PermissionDAO.queryUserPermission()` 查询权限

3. 历史兼容逻辑:
   - `LegacyAuthAdapter.java:L33`
   - 兼容旧版角色映射,是否仍需保留待确认

## Open Questions
- `RpcPermissionInterceptor` 是否仍有调用方?
- “细粒度授权”第一期是否只到接口级?

Research 完成标准:

  • 入口、链路、依赖、风险都已锁定。
  • 每个结论有代码出处。
  • 模型主动暴露不确定项。
  • 所有发现写回 Spec,而不是停留在聊天里。

Innovate:强制多方案对比

复杂任务不要让模型直接给一个方案。一个方案往往意味着没有选择,也很容易陷入局部最优。

提示词可以这样写:

请进入 Innovate 阶段。基于 Research Findings 给出 2~3 个方案。

每个方案必须包含:
- 核心思路
- 需要修改的文件
- 优点
- 缺点
- 风险点
- 工作量估算

不要直接写代码。人确认方案后再进入 Plan。

输出结构示例:

## Option A: 统一入口 + 策略模式

### 核心思路
新增 `UnifiedPermissionGateway`,HTTP 和 RPC 入口都委托给统一网关,网关内部按请求类型选择策略。

### 修改文件
- `PermissionFilter.java`
- `RpcPermissionInterceptor.java`
- `UnifiedPermissionGateway.java`
- `UnifiedPermissionGatewayTest.java`

### 优点
- 入口统一,后续维护成本低
- 权限策略集中,方便扩展

### 缺点
- 改动面较大
- 需要完整回归 HTTP 和 RPC 两条链路

### 风险
- RPC 拦截器调用方尚未确认

### 工作量
约 2 天

## Option B: 适配器模式 + 渐进迁移
...

如果只是改配置、修文案、补一处空指针,可以在 Spec 中记录:

## Innovate
Skipped.

Reason: 单点修改,边界清晰,不需要多方案对比。

方案选定后必须写回 Spec,记录选了哪个方案以及原因。

Plan:精确到文件路径和函数签名

Plan 是 SDD-RIPER 的关键门禁。Plan 如果看不懂,就不能进入 Execute。

合格 Plan 必须满足:

  • 精确到文件路径。
  • 新增类、函数要给出签名。
  • 修改点要说明改什么,不只写“优化逻辑”。
  • 标明执行顺序。
  • 每一步都有验证方式。
  • 风险和回滚点清晰。

示例提示词:

请进入 Plan 阶段。基于已选方案 A,输出原子级实施清单。

要求:
1. 精确到文件路径和函数签名。
2. 标明执行顺序和依赖关系。
3. 标明每一步的验证方式。
4. 不要写代码。

Plan 示例:

## Implementation Checklist

- [ ] 1. 新建 `src/main/java/com/example/permission/UnifiedPermissionGateway.java`
  - `public class UnifiedPermissionGateway implements PermissionChecker`
  - `public boolean checkPermission(PermissionContext ctx)`
  - `private PermissionStrategy resolveStrategy(RequestType type)`
  - 验证:新增单元测试覆盖 HTTP / RPC 两类请求

- [ ] 2. 修改 `src/main/java/com/example/filter/PermissionFilter.java`
  - 将 `doFilter()` 中的权限校验逻辑委托给 `UnifiedPermissionGateway`
  - 保留原异常处理逻辑
  - 验证:HTTP 无权限场景返回原错误码

- [ ] 3. 修改 `src/main/java/com/example/rpc/RpcPermissionInterceptor.java`
  - 将 `invoke()` 中的权限校验逻辑委托给 `UnifiedPermissionGateway`
  - 验证:RPC 鉴权失败时抛出原异常类型

- [ ] 4. 新建 `src/test/java/com/example/permission/UnifiedPermissionGatewayTest.java`
  - 覆盖 HTTP 请求、RPC 请求、无权限、超级管理员四种场景

## Execution Order
1 -> 2 -> 3 -> 4

## Risks
- RPC 拦截器调用方未完全确认,执行前需要人工确认是否仍在线上链路中。

审批时重点看五件事:

检查项问题
可理解性每一步是否能看懂
路径准确性文件路径、函数名是否真实存在
顺序合理性是否先建基础能力,再接入入口,再补测试
范围控制有没有顺手重构无关模块
风险暴露未确认事项有没有被标记

确认后只需要回复:

Plan Approved.

没有这句话,模型不能进入 Execute。

Execute:只允许按图施工

Execute 阶段不再讨论大方向,模型只做已批准 Plan 中的事情。

启动提示词:

Plan Approved.

请进入 Execute 阶段,严格按照 Plan 逐步执行。
要求:
- 每完成一步报告进度。
- 如果发现 Plan 有问题,立即停止并说明原因。
- 编译错误、类型不匹配可以修复。
- 任何逻辑变更必须回到 Plan 阶段重新审批。

执行日志应写回 Spec:

## Execute Log

- [x] Step 1: 已创建 `UnifiedPermissionGateway.java`
  - 实现 `checkPermission()`
  - 实现 `resolveStrategy()`

- [x] Step 2: 已修改 `PermissionFilter.java`
  - HTTP 权限校验委托给统一网关
  - 原异常处理逻辑保留

- [ ] Step 3: 进行中

Execute 阶段的禁忌:

  • 不允许“顺手重构”。
  • 不允许扩大修改范围。
  • 不允许跳过 Plan 中的步骤。
  • 不允许发现 Plan 不合理后偷偷改成另一个方案。
  • 不允许开启无审批全自动模式。

Review:对照 Spec 验收,不是只看代码能不能跑

Review 不只是跑测试。它要确认文档预期、实际代码、执行过程三者一致。

提示词示例:

请进入 Review 阶段。对照 Spec 逐条验收:

1. Spec 中的目标行为是否全部落地?
2. 实际改动是否偏离 Plan?
3. 有没有隐性破坏、边界条件遗漏或安全风险?
4. 测试是否覆盖关键路径?
5. Review 结论写入 Spec 的 Review Verdict。

Review 输出可以用矩阵:

## Review Matrix

| 检查轴 | 结果 | 说明 |
|---|---|---|
| Spec 达成率 | PASS | 4/4 个目标行为已实现 |
| Plan-Execution Diff | PASS | 实际改动未偏离 Plan |
| 代码质量与弱点 | FAIL | `UnifiedPermissionGateway.java:L52` 缺少空指针守卫 |

## High Risk Issues

1. `UnifiedPermissionGateway.java:L52`
   - 问题:`ctx` 可能为空,当前代码会触发 NPE
   - 建议:添加 `Objects.requireNonNull(ctx, "ctx")`
   - 处理:回到 Plan 阶段补充修复步骤

## Verdict
NO-GO

Review 不通过时,不要直接让模型“修一下”。正确做法是:

  1. 回到 Plan。
  2. 把修复步骤写进 Plan。
  3. 人审批。
  4. 再 Execute。
  5. 再 Review。

Archive:把一次交付变成可复用资产

任务结束后,要把过程材料压缩归档。否则 Spec 越积越长,后续模型和人都难读。

可以要求模型生成两份归档:

请执行 archive,将当前功能的规格、方案、关键决策和实现逻辑沉淀下来。
输出:
1. Human 视角版:给人阅读和交接。
2. LLM 视角版:给下一次大模型恢复上下文。

推荐产物:

mydocs/specs/archive/
├── 2026-06-07_permission-refactor_human.md
└── 2026-06-07_permission-refactor_llm.md

Human 视角版应该包含:

  • 需求目标。
  • 最终方案。
  • 修改范围。
  • 关键风险。
  • 验收结果。
  • 后续维护建议。

LLM 视角版应该更像压缩索引:

  • 业务背景。
  • 核心数据结构。
  • 关键文件路径。
  • 入口和调用链。
  • 已知约束。
  • 常见坑。
  • 后续任务需要优先读取的文件。

Archive 的意义是让团队的 AI 编程能力不随对话结束而归零。

一周落地 SOP

团队推广不适合一上来全量铺开。更稳的方式是用一个低风险老需求试点,跑通后再扩散。

Day 1~2:选一个老需求试点

老需求适合试点,因为边界清晰、风险较低,还能验证低经验同学是否能在流程约束下接手老业务。

操作清单:

  1. 核心研发花 1~2 小时生成 CodeMap。
  2. 把需求整理成简短文档,包含目标、范围、约束、验收标准。
  3. 指定一位低经验同学按 SDD-RIPER 完成需求。
  4. 核心研发只做两件事:审 Plan、最终 Review。

角色分工:

角色责任
核心研发生成初始 CodeMap,审批 Plan,做最终 Review
执行同学维护 Spec,驱动 RIPER 流程,按 Plan 交付
TL观察周期、质量、卡点和可复制性

Day 3~4:复盘和修正规则

复盘不要只问“感觉怎么样”,要看具体证据。

复盘项判断标准
需求是否完成是否达到 Spec 中的验收标准
Plan 是否有效是否提前拦住明显风险
Research 是否充分是否每个关键结论都有代码出处
Spec 是否可复用另一个人能否靠 Spec 理解任务
周期是否缩短与传统交付方式相比节省了多少时间
质量是否稳定Review 中发现的问题数量和严重程度

常见调整:

问题修正方式
Plan 太粗要求拆到文件路径和函数签名
Research 太浅补 CodeMap 或缩小 scope 重跑
模型频繁跑偏强化 Spec 边界和 Plan Approved 门禁
同学不习惯用固定模板减少心智负担
Review 压力大使用三轴 Review 矩阵,只审关键偏差

Day 5~7:扩大到更多需求

试点通过后再扩大范围:

  1. 换一个人做第二个需求,验证流程是否可复制。
  2. 核心研发负责写 Spec 和审 Plan,多个同学并行 Execute。
  3. 把试点 Spec、CodeMap、Review 矩阵沉淀为团队模板。
  4. 建立团队规则:没有 Spec 不接需求,没有 Plan Approved 不改代码。

指标怎么量化

团队推广大模型编程,必须有量化指标。只说“效率变高了”没有意义。

可以从四类指标看效果:

指标类型指标说明
质量Bug 率、回滚次数、Review 高危问题数看质量是否可控
效率需求周期、并行需求数、返工轮次看交付是否变快
协作接手周期、核心研发 Review 时间、交接次数看人力是否解耦
成本token 消耗、缓存命中率、对话轮次看调用成本是否可控

已有落地统计中出现过这样的量级:

指标变化
主语言 Java Bug 率下降 18%
非主语言 Go / Python / Node.js Bug 率下降 37%
日常需求周期1~2 周缩短到 3~4 天
大型需求周期2 个月缩短到 1 个月
大客户交付人力节省 40%
团队整体效率增加 55%

这些数字不能直接照搬成所有团队的承诺,更适合作为目标量级和度量口径。真正要落地,还是要用团队自己的试点数据说话。

常见问题

Spec 最小要写多详细?

小任务的最小 Spec 只需要五个字段:

# Spec: <任务名>

## 目标
要达成什么结果。

## 范围
改哪些模块,不改哪些模块。

## 约束
兼容性、性能、安全、接口、上线窗口等限制。

## 风险
不确定项、历史逻辑、可能影响的调用方。

## Checklist
- [ ] 验收点 1
- [ ] 验收点 2

复杂任务再扩展:

## Research Findings
## Innovate Options
## Selected Decision
## Plan Checklist
## Execute Log
## Review Verdict
## Archive Summary

先跑通流程比写一份完美 Spec 更重要。

老项目 Research 很慢怎么办?

老项目启动慢很正常。不要每次需求都重新痛苦扫描,可以专门做一次索引建设:

  • 按功能切片生成 3~5 份高价值 CodeMap。
  • 不追求一次性覆盖整个项目。
  • 每次新需求补一块相关链路。
  • CodeMap 由团队共享,避免每个人重复认路。

老项目越早沉淀 CodeMap,后续复利越明显。

团队里有人不愿意用怎么办?

不要靠说服,靠流程和结果。

可执行做法:

  • 找愿意尝试的人跑一个低风险需求。
  • 记录周期、Review 问题、返工次数。
  • 把产出的 Spec 和 CodeMap 做成模板。
  • 团队统一一条硬规则:未经 Plan Approved 不得改代码。

当流程进入日常协作,不愿意用的人也会被最小门禁带入 RIPER。

代码不能出内网,能用外部模型吗?

可以采用双模协作:

模型位置任务是否接触源码
内部模型读代码、生成 CodeMap、产出脱敏 Spec
外部模型基于脱敏 Spec 做方案对比、架构推演、Review 辅助

关键原则是代码不出内网,Spec 作为中间层隔离敏感信息。脱敏 Spec 里不要包含密钥、客户数据、内部域名、敏感接口细节。

线上 Bug 怎么结合 SDD-RIPER 排查?

排障时可以把 Debug 流程纳入同一套机制:

输入材料:

  • 出事节点日志。
  • 报错堆栈。
  • 用户请求或任务参数。
  • 相关功能最初的 Spec。
  • 当前版本 diff。

排查过程:

flowchart LR
    A[日志与报错] --> D[Debug Spec]
    B[原始 Spec] --> D
    C[当前代码] --> D
    D --> E[预期 vs 现实差异]
    E --> F[定位可疑文件和函数]
    F --> G[修复 Plan]
    G --> H{Approved?}
    H -- 是 --> I[补丁 Execute]
    H -- 否 --> G
    I --> J[Review + 回归]

Bug 修复也要遵守 Reverse Sync:先把修复方案写进 Spec,再改代码。

SDD-RIPER 会不会污染上下文窗口?

协议本身不是上下文杀手。真正消耗上下文的是无序试错、重复解释、散落的聊天记录和模型跑偏后的返工。

可用三层方式控制上下文:

机制做法
分层加载当前阶段只加载必要信息,历史细节放冷上下文
落盘复用Spec、CodeMap、Context Bundle、Review 结论都写入文件
轻重分流小任务用 Light 流,复杂任务用标准流

RIPER 管流程,Spec 管记录,模型按需取用。只要不把所有文档每轮都塞进对话,SDD-RIPER 不会变成上下文负担。

可直接使用的团队规则模板

可以把以下内容放进 AGENTS.md 或团队 AI 编程规范里:

# AI 编程工作指南

## 基本规则

- 使用中文交流。
- No Spec, No Code:没有 Spec,不准改代码。
- No Approval, No Execute:没有明确批准,不准进入 Execute。
- Spec is Truth:代码和 Spec 冲突时,先对齐 Spec。
- Reverse Sync:发现 Bug 或需求变化,先更新 Spec,再修改代码。

## Skill 使用约定

- 默认使用 `sdd-riper-one`。
- 任务简单、边界清晰、改动很小时,可以使用 `sdd-riper-one-light`。
- 极小修改可不启用完整流程,但必须说明修改范围和验证方式。

## 执行规则

- 代码修改前必须提交 Plan 并等待确认。
- 文档修改可以直接执行,但影响行为的文档变更要同步到 Spec。
- 修改文件时优先小步提交,避免整文件重写。
- 不做与当前任务无关的重构。
- 多文件改动时,先完成核心链路的最小可用修改,再补齐周边逻辑。
- 如果连续两轮只搜索、不修改,必须停止并说明准备改哪些文件、为什么。

## 命令边界

- 未经确认,不主动运行编译、打包、部署、迁移等高开销或高风险命令。
- 未经确认,不主动安装、升级、删除依赖或修改锁文件。
- 对批量删除、覆盖、重置、迁移、外部写操作,必须等待确认。

## Git 边界

- 严格尊重 `.gitignore`。
- 不主动使用 `git add -f` 或 `git add --force`。
- 不执行 `git clean`,尤其不要执行 `git clean -fdx`。
- 被忽略文件默认不提交,除非明确指定路径。

## Spec 同步

- 影响需求、接口、行为、约束、流程或实现决策时,执行后必须同步更新 Spec。
- 纯格式化、注释调整、机械性改动可不更新 Spec。

关键规则清单

规则含义
No Spec, No Code没有任务 Spec,不开始写代码
Spec is TruthSpec 是任务真相源,代码必须对齐它
Reverse Sync发现偏差时,先修 Spec,再修代码
Plan Approved人批准 Plan 后,模型才能 Execute
关闭全自动模式禁止模型先斩后奏
发现必须回写Research、Plan、Review 结果都要沉淀到文件
AI 提问是好事模型暴露不确定项,比假装确定更安全

SDD-RIPER 的目标不是让大模型替代工程判断,而是把大模型放进可控流程里。模型负责高速度的信息整理、方案展开和代码生成;人负责边界、决策、审批和最终质量。团队只要先守住“未经 Plan Approved 不得改代码”这条线,就已经从随机聊天式编程迈进了可治理的大模型编程。


评论