《AI Agent 游戏产品开发》13.2 从单点到系统性能力的路线图

路线图不是按季度切分的甘特图,而是一张依赖图:没有观测就做不了灰度,没有降级就放不了量,没有评测就无法判断改动是否变差。本节给出五个阶段、四条硬依赖、有环路线图的判定、关键路径的计算,以及消消 18 周与方舟 23 周两条路线的差异。阶段名与成熟度分级共用一套口径。

以下人物、公司与数字均为教学假设,不构成对任何真实产品的评价。阶段划分、周期与依赖关系均为方法示例,不构成项目排期建议。

《潮汐消消》年初排了一张 12 个季度的 AI 路线图,从「赛后点评」一路排到「全玩法陪伴」。《潮汐方舟》排了 8 个季度,从「AI 对手」排到「NPC 社会」。

两张图都很漂亮,横轴是时间,纵轴是功能。执行到第二季度,两家都卡住了,而且卡在同一处:观测还没做,后面的功能已经排到了明年。

问题不在执行速度,在图的形状。甘特图假设任务可以并行、可以按时间切片;Agent 能力不是这样,它们之间有硬依赖。

路线图不是甘特图

甘特图回答「什么时候做什么」,路线图要回答「什么必须先于什么」。两者的区别在出问题时的表现:

形态计划方式延期时的反应交付后的状态
甘特图按季度切功能加班、砍范围、并行补功能齐了,但无法判断好坏
依赖图按前置条件排能力回到前置,先补依赖每个能力都有验收依据

Agent 产品最常见的延期不是「做得慢」,而是「做完发现没法验」。灰度需要观测,观测需要指标口径,指标口径需要所有权;这条链上任何一环缺失,后面做完的功能都只能靠感觉判断。

所以路线图的节点不是功能名,而是能力;节点之间不是时间顺序,而是依赖关系。

五个阶段

成熟度分级给出位置,路线图给出路径。两者用同一套阶段名:

阶段名称进入条件退出条件
0未成形—有一个稳定触发的场景与脚本基线
1单点场景与脚本基线时间上限、退出路径、开关都可用
2兜底单点可运行降级演练通过,指标与告警上线
3可评测兜底可重复评测集、回归、灰度与红线齐备
4可治理评测可比较所有权、预算、事故与跨产品口径固化

阶段是能力状态,不是时间刻度。一个产品可以在阶段 2 停留很久,也可以在一个季度内从 1 到 3;关键是不要跳过阶段——从 1 直接做 4,做出来的是没有刹车的社会模拟。

四条硬依赖

本书的路线图只有四条硬依赖,其余都是软依赖:

  1. 观测先于灰度。 没有指标,灰度放量只是「放出去看看」,出问题也不知道该回滚到哪一版。
  2. 降级先于放量。 降级路径没演练过,模型一抖动就只能全量关停,损失比降级大得多。
  3. 评测先于实验。 没有基线,对照实验的结论无法归因;实验组变好可能是因为活动,不是因为 Agent。
  4. 所有权先于预算。 没有所有权人,预算超了没人负责;平台会默认「先停掉最贵的调用」,而不是最没价值的调用。

这四条对应前十二章的结论:观测来自 11.1,降级来自 3.3,评测来自 12.2,所有权来自 12.1。路线图不是新方法,是把已有结论排成顺序。

有环的路线图不能执行

依赖图最危险的不是排得长,而是成环。成环的典型写法有三种:

  • 「先做 NPC 社会,再补观测。」 NPC 社会需要观测来判断是否失控(8.2),没有观测就上社会模拟,等于蒙眼开车。
  • 「先放量,再补降级。」 放量后模型抖动,只能全量关停;关停本身就是最粗暴的降级,但没有分级路径。
  • 「先做多场景复用,再统一评测口径。」 复用需要同一把尺子,没有尺子就只能按功能清单复用,复用的是代码不是判断。

三种写法的共同点是「把后置条件写成前置任务」。排期时看不出来,执行到一半才发现绕不回去。

代码里的处理是直接报错:validate 检测到环就返回 dependency cycle,schedule 拒绝排期。路线图有环,说明计划本身不可执行,不是执行不力。

关键路径决定最早上线

依赖图排好之后,总工期不是各节点周期之和,而是最长路径。两条案例的差别很直观。

消消的路线:

能力周期前置完成周
观测与指标2 周—2
降级路径2 周观测4
评测集3 周观测5
赛后点评4 周降级8
关卡提示3 周评测8
活动向导4 周赛后点评、关卡提示12
全玩法陪伴6 周活动向导18

关键路径是「观测 → 评测 → 关卡提示 → 活动向导 → 全玩法陪伴」,共 18 周。赛后点评不在关键路径上:它有 4 周余量,晚两周开始也不会推迟最终上线。

方舟的路线:

能力周期前置完成周
观测与指标3 周—3
降级路径2 周观测5
评测集4 周观测7
AI 对手6 周降级11
剧情 NPC5 周评测12
战术建议3 周AI 对手、剧情 NPC15
NPC 社会8 周战术建议23

关键路径是「观测 → 评测 → 剧情 NPC → 战术建议 → NPC 社会」,共 23 周。方舟比消消多 5 周,多出来的不是功能数量,是实时与公平带来的观测与评测成本。

关键路径也是资源分配依据:想提前上线,只能压缩关键路径上的节点;压缩非关键路径,总工期一周都不会变。

每周只看 ready 清单

路线图最常见的用法错误,是把它当进度表,每周问「做到哪了」。更有效的问法是「这周能开工哪些」。

ready 返回的是前置已全部完成、自身尚未完成的能力。它的价值在于排除:

  • 前置没完成的能力,即使人力空闲也不该开工,否则会做出无法验收的半成品。
  • 已经完成的能力不会重复出现,避免「再做一遍」。
  • 多个能力同时 ready 时,按关键路径优先级排序,而不是按谁先提需求。

消消在第一周的 ready 清单只有「观测与指标」一项。这不是保守,是依赖决定的:降级与评测都要等观测的口径定下来。方舟在观测完成后,ready 清单同时出现「降级路径」与「评测集」,这时才需要并行。

路线图要随评测结果改

路线图不是一次排完就锁死。三类事件会触发重排:

事件影响处理
评测不通过当前能力不能进入下一阶段把缺口补成新节点,插在当前能力之后
事故复盘发现新依赖原依赖链缺一环插入节点,并重算关键路径
产品目标变化某条路线的价值下降删除节点,同时删除依赖它的下游

重排要留记录:改了什么、为什么改、关键路径从多少周变成多少周。没有记录的重排,三个月后没人说得清当前路线为什么长这样。

重排频率建议每季度一次,与 13.1 的复评节奏对齐。评测不通过时立即重排,不等季度会。

把路线图写成可执行依赖图

下面的实现把依赖校验、拓扑排序、完成周计算、关键路径与本周可开工清单写成纯函数。

// file: src/govern/roadmap.ts
// tier: L1
// verify: node --test test/govern/roadmap.test.ts

// 路线图不是时间表,是依赖图:先有观测才能灰度,先有降级才能放量。
// 有环的路线图不能执行;关键路径决定最早能上线的时间。

export type Capability = {
  readonly id: string;
  readonly label: string;
  readonly weeks: number;
  readonly requires: readonly string[];
};

export type Schedule = {
  readonly order: readonly string[];
  readonly finish: Readonly<Record<string, number>>;
  readonly totalWeeks: number;
  readonly critical: readonly string[];
};

export const PHASES: readonly string[] = ["未成形", "单点", "兜底", "可评测", "可治理"];

export function phaseOf(level: number): string {
  return PHASES[Math.max(0, Math.min(PHASES.length - 1, level))];
}

export function validate(capabilities: readonly Capability[]): readonly string[] {
  const errors: string[] = [];
  const ids = new Set(capabilities.map((item) => item.id));
  if (ids.size !== capabilities.length) errors.push("duplicate capability id");
  for (const item of capabilities) {
    if (!Number.isInteger(item.weeks) || item.weeks < 1) {
      errors.push(`${item.id}: weeks must be a positive integer`);
    }
    for (const requirement of item.requires) {
      if (!ids.has(requirement)) errors.push(`${item.id}: unknown requirement ${requirement}`);
    }
  }
  if (hasCycle(capabilities)) errors.push("dependency cycle");
  return errors;
}

function hasCycle(capabilities: readonly Capability[]): boolean {
  const byId = new Map(capabilities.map((item) => [item.id, item]));
  const visiting = new Set<string>();
  const done = new Set<string>();
  const walk = (id: string): boolean => {
    if (visiting.has(id)) return true;
    if (done.has(id)) return false;
    const item = byId.get(id);
    if (item === undefined) return false;
    visiting.add(id);
    for (const requirement of item.requires) {
      if (walk(requirement)) return true;
    }
    visiting.delete(id);
    done.add(id);
    return false;
  };
  return capabilities.some((item) => walk(item.id));
}

export function schedule(capabilities: readonly Capability[]): Schedule {
  const errors = validate(capabilities);
  if (errors.length > 0) throw new Error(errors.join("; "));
  const byId = new Map(capabilities.map((item) => [item.id, item]));
  const order: string[] = [];
  const seen = new Set<string>();
  const visit = (id: string): void => {
    if (seen.has(id)) return;
    seen.add(id);
    const item = byId.get(id);
    if (item === undefined) return;
    for (const requirement of item.requires) visit(requirement);
    order.push(id);
  };
  for (const item of capabilities) visit(item.id);

  const finish: Record<string, number> = {};
  for (const id of order) {
    const item = byId.get(id) as Capability;
    const start = Math.max(0, ...item.requires.map((requirement) => finish[requirement]));
    finish[id] = start + item.weeks;
  }
  const totalWeeks = Math.max(0, ...Object.values(finish));
  return { order, finish, totalWeeks, critical: criticalPath(byId, finish) };
}

function criticalPath(
  byId: ReadonlyMap<string, Capability>,
  finish: Readonly<Record<string, number>>,
): readonly string[] {
  if (byId.size === 0) return [];
  const latest = [...byId.values()].sort(
    (left, right) => finish[right.id] - finish[left.id] || left.id.localeCompare(right.id),
  )[0];
  const path: string[] = [latest.id];
  let current = latest;
  while (current.requires.length > 0) {
    const next = [...current.requires].sort(
      (left, right) => finish[right] - finish[left] || left.localeCompare(right),
    )[0];
    path.push(next);
    current = byId.get(next) as Capability;
  }
  return path.reverse();
}

// 只返回前置已全部完成、自身尚未完成的能力;这就是本周真正能开工的清单。
export function ready(
  capabilities: readonly Capability[],
  done: readonly string[],
): readonly string[] {
  const finished = new Set(done);
  return capabilities
    .filter((item) => !finished.has(item.id))
    .filter((item) => item.requires.every((requirement) => finished.has(requirement)))
    .map((item) => item.id);
}

validate 一次返回全部错误,而不是遇到第一个就停。排期会议上有时候需要一次看到「三个未知依赖 + 一个环」,逐个报错会让会议来回三轮。

hasCycle 用三色标记:访问中、已完成、未访问。只记录「访问过」无法区分「正在这条路径上」与「另一条路径已经走完」,会把合法菱形依赖误报成环。

schedule 先拓扑排序再累加完成周。排序保证前置一定先算,finish 才能用 Math.max 取所有前置的最晚完成时间;直接按输入顺序算,会把后出现的依赖算错。

criticalPath 从最晚完成的能力往回走,每次选前置里完成周最大的那个。它给出的是「哪条链决定了总工期」,不是「哪条链最长」——两者在有并行分支时不是一回事。

ready 只做集合判断,不排序。排序是产品决策,函数只负责回答「现在能不能开工」;把优先级写进函数,会让每个团队都去改同一段代码。

路线图要能被非技术角色读懂

路线图最终要给策划、运营和老板看。三件事必须写在图外:

  • 每个节点的验收标准。 「AI 对手上线」不是验收,「AI 对手在 800ms 内做出与脚本策略同等强度的决策,且回放可审计」才是。
  • 每个阶段的退出证据。 与 13.1 的证据规则一致,没有证据的阶段不算完成。
  • 哪些节点可以砍。 砍掉一个非关键路径节点,工期不变;砍掉关键路径节点,必须同时调整上线时间。这张清单能避免「什么都想要、什么都不砍」的会议。

小结

  • 路线图是依赖图,不是甘特图;节点是能力,边是前置条件。
  • 五个阶段:未成形、单点、兜底、可评测、可治理,阶段不能跳。
  • 四条硬依赖:观测先于灰度、降级先于放量、评测先于实验、所有权先于预算。
  • 有环的路线图不可执行;检测到环应当停下改计划,而不是加班。
  • 总工期由关键路径决定,压缩非关键路径不会提前上线。
  • 每周只看 ready 清单:前置未完成的能力,人力空闲也不开工。
  • 消消关键路径 18 周,方舟 23 周;差的 5 周来自实时与公平的观测成本。
  • 评测不通过、事故发现新依赖、产品目标变化,都会触发重排;重排要留记录。
  • 每个节点要有验收标准,每个阶段要有退出证据。
  • 路线图给非技术角色看时,必须写清哪些节点可以砍。

阅读导航:上一节:13.1 成熟度分级 L1–L4 · 下一节:13.3 全书评审与下一步 。

常见错误与边界

  1. 把路线图画成甘特图。 按季度切功能,做完发现无法验收;依赖关系被时间刻度掩盖。
  2. 跳过观测直接做灰度。 放量后出问题不知道该回滚到哪一版,只能全量关停。
  3. 先放量再补降级。 模型抖动时没有分级路径,损失比提前做降级大得多。
  4. 把后置条件写成前置任务。 「先做社会模拟再补观测」是环,排期时看不出来,执行到一半绕不回去。
  5. 用节点周期之和估工期。 并行分支会被重复计算;总工期只看关键路径。
  6. 每周问「做到哪了」。 进度表不能告诉你现在能不能开工;ready 清单才能。
  7. 压缩非关键路径。 赛后点评提前两周,全玩法陪伴仍然第 18 周上线,总工期不变。
  8. 路线图排完就锁死。 评测不通过、事故发现新依赖、目标变化都会让原图失效;季度重排是常态。
  9. 节点没有验收标准。 「上线」不是标准;延迟、强度、可审计性才是。
  10. 把阶段当时间。 阶段是能力状态,可以停留很久,也可以快速通过;跳过阶段才会出事。

路线图回答「怎么走」。走完之后还需要一次收口:全书十二章的结论,团队到底落实了几条,哪些是证据,哪些只是印象。下一节把评审写成门禁,并给出本书之外的三件下一步工作。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图