想象你请了一位手脚麻利到不可思议的 AI 装修工:你说“阳台加个储物柜”,它半小时就给你打好了;你说“客厅电路改一下”,它也立马开工。这就是 Vibe Coding——用自然语言开车,让 AI 写代码。问题在于,这位装修工有个致命毛病:不记事。它从不画图纸、不写施工日记,上一次的活儿干完就忘。房子刚装好时你欢天喜地,可住几个月后要换个插座,你连埋在墙里的电线走向都不知道。装修只要一个周末,过日子却要十年——AI 写项目也一样:跑起来只花一天,维护它却要跑一年。这篇指南讲的就是怎么让 AI 盖的房子“走得远”:用文档当施工图,用架构当承重墙,用计划还技术债,用测试当验收机,用规范做团队语言,用交接棒传递知识,让 AI 的“快”和项目的“稳”兼得。

岗位关联

掌握这套维护策略,你就能把 AI 编程的速度红利转化为长期交付优势——无论团队怎么变动、需求怎么变化,AI 辅助项目都能稳稳演进。这是 Vibe Coding 时代团队负责人和资深开发者最核心的竞争力。

目录
  1. 可视化演示
  2. 文档建设:给未来的自己留一张施工图
  3. 架构演进:承重墙不能拆,隔断墙小步改
  4. 技术债管理:利息会吃掉你的房子
  5. 质量防线:装一台自动打压机
  6. 团队协作:让知识长在团队里
  7. 人员延续:接力棒要拿得住
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示Dijkstra算法在加权图中逐步探索最短路径的过程,从源点出发贪心扩展,最终得到到所有节点的最短距离。

本节配有交互动效(进入视口后自动加载,约 3KB)。

初始化阶段 设置源点距离为0,其他节点距离为∞ 所有节点标记为未访问 dist[S] = 0, dist[v] = ∞

文档建设:给未来的自己留一张施工图

那个 AI 装修工最让人头疼的,不是干活慢,而是干活“忘”。你在周三让它给阳台做了防水,周五再问它用的什么材料,它一脸茫然——因为它的记忆只存在于那一次对话里,会话一关,一切清零。Vibe Coding 的代码也是这样:AI 写的时候思路清楚,写完之后它自己也不记得为什么要这么写。想让这栋房子住十年,最要紧的不是当初砌得多快,而是墙上有没有施工图、抽屉里有没有装修手册。项目的施工图,就是文档。

Vibe Coding 项目里的代码天然“能跑但不好懂”。AI 为了一次生成成功,倾向于写长函数、重复逻辑,而且不会主动解释“这里为什么特殊处理”。所以文档建设不是给公司交差的形式主义,而是对抗 AI“无记忆”本性的基础设施。优先做四件事:一是注释规范——约定 AI 生成的代码必须补“为什么”注释,而不是流水账式的“是什么”;二是 README 维护——每次大变更后同步更新,让新人和新的 AI 会话五分钟上手;三是 ADR(架构决策记录)——把“当时为什么选这个方案”写成文档;四是知识库沉淀——把踩过的坑、排查过的问题收进团队 wiki。

文档为什么能长期省钱?可以用一个直观模型来看——理解成本:

回到房子:住十年,图纸和施工记录比当初的速度值钱得多。每次让 AI 改完代码,顺手补一段注释、更新一处 README,就像在墙上贴一张“此处有水管”的标签——下次无论是哪个装修工进场,都不会一锤子砸坏它。

C理解=S代码复杂度×N团队规模D文档完整度\displaystyle C_{\text{理解}} = \frac{S_{\text{代码复杂度}} \times N_{\text{团队规模}}}{D_{\text{文档完整度}}}
翻译成人话:代码越绕、要读懂它的人越多,团队要花的理解功夫就越大;文档越完整,这笔功夫被摊得越薄。Vibe Coding 团队文档不是“有空再写”,而是让项目活得下去的必要开销。
  1. S 代码复杂度分子第一项。AI 倾向用最直接的写法堆功能,分支多、命名随意、魔法数字到处都是,这些都会把 S 拉高。复杂度越高,任何人(包括未来的 AI 会话)要理解这段代码的成本就越高。
    S=w1×分支数+w2×模块间引用数S = w_1 \times \text{分支数} + w_2 \times \text{模块间引用数}
  2. N 团队规模分子第二项。每个新成员、每个新的 AI 会话都要从头读代码。读的人越多,总理解成本按人头累加——这就是为什么“两个人的项目不写文档”还能撑住,二十个人的项目不写文档必乱。
    N=人类成员数+活跃 AI 会话数N = \text{人类成员数} + \text{活跃 AI 会话数}
  3. D 文档完整度分母上的质量因子。注释、README、ADR 越全,每个人摸索的时间越短。它的本质是把“一次性写代码的快”兑换成“长期读代码的省”。
    D=已维护文档页数应维护文档页数D = \frac{\text{已维护文档页数}}{\text{应维护文档页数}}

架构演进:承重墙不能拆,隔断墙小步改

老房子最怕什么?为打通客厅和阳台,有人把中间的承重墙砸了,整栋楼出现裂缝。懂建筑的人都知道,墙分两种:承重墙管着整栋楼的命,非承重墙只是隔断。Vibe Coding 项目里最大的隐患,就是 AI 分不清这两种墙——你让它“删掉这段代码”,它从不反问“这是不是承重墙”。

所以架构演进的策略不是“先设计一个完美架构”,而是反复做四件事:第一,模块化拆分——把项目按业务领域切成独立“房间”,每个房间有清晰的对外入口;第二,边界守护——明确核心模块的访问规则,AI 改代码时禁止绕过封装直接修改内部;第三,依赖管理——引进新库必须伴随一条 ADR 记录,升级依赖走小步快跑;第四,重构节奏——每个迭代只重构一个模块,改完立刻验证。本质上,你要把“哪些不能动”变成一道道闸门,而不是靠每个人自觉。

如何量化“墙拆没拆对”?看模块耦合度:

守住承重墙不是不让动结构,而是让你知道哪些墙能砸、怎么砸。给 AI 一份“允许修改区域”的清单,它才能既快又不闯祸。

耦合度=∑跨模块直接调用次数模块总数\displaystyle \text{耦合度} = \frac{\sum \text{跨模块直接调用次数}}{\text{模块总数}}
这个比值衡量的是模块之间的“私闯民宅”次数。每次 A 模块直接摸 B 模块的内部数据,就记一次账。比值越大,墙越薄,牵一发而动全身。
  1. Σ 跨模块直接调用次数分子,统计所有模块之间“越过封装、直接操作内部”的次数,比如直接改别的模块的全局变量、绕过公开接口调用内部函数。每发生一次,都意味着未来修改时多一处“不知道谁会受影响”的地雷。
    ∑i=1nCrossCalli\sum_{i=1}^{n} \text{CrossCall}_i
  2. 模块总数分母,用来消除项目规模的影响。10 个模块各调 1 次,和 100 个模块各调 1 次,耦合度数值一样,但绝对风险完全不同——所以分母让这个指标更适合横向对比。
    M=模块总数M = \text{模块总数}
  3. 整体含义耦合度高的项目,AI 修一个 bug 可能顺带引爆三个模块;把耦合度降下来,AI 改代码就像在隔断墙上开门,不影响整栋楼的承重结构。
    可维护性∝1耦合度\text{可维护性} \propto \frac{1}{\text{耦合度}}

技术债管理:利息会吃掉你的房子

装修行有句话叫“隐蔽工程”——水管电线埋进墙里,装好的时候谁也看不见、验不了,等漏水那天发现,得先砸墙。Vibe Coding 把隐蔽工程加速了:为了让功能“能跑”,AI 常常用临时方案交差——硬编码的配置、绕弯的调用、复制粘贴的逻辑。这些东西刚写完时跑得挺好,但它们是埋在墙里的雷。

技术债最可怕的不是“欠了多少”,而是利息按复利滚。借过房贷的人都知道,晚还一个月,利息是按复利算的;代码里的债更狠:烂结构上每叠一个功能,改动都更费力,每修一次都在乱麻上再打一个结。有一个经典模型描述这种恶化的成本:

技术债治理分四步走:识别——通过代码审查和定期扫描,把“以后会痛”的地方标出来;分级——按“影响面 × 发生概率”打标签,S 级债务必须下个迭代还;偿还——每个迭代固定留出 20% 工时还债,像还房贷一样雷打不动;监控——用模型估算总债务量,画成曲线贴在看板上,让债务公开可见。

把技术债看成房子的老化:每年做一次全屋体检,小裂缝当场补,大问题排期修。千万别等墙皮掉光才发现钢筋锈断——那时砸墙的钱,够买半套新房。

偿还成本=P×(1+r)t\displaystyle \text{偿还成本} = P \times (1 + r)^{t}
通俗讲:P 是本金(当时欠下的返工量),r 是每个迭代的恶化率(因为结构混乱多付出的修改成本比例),t 是选择忽略的迭代数。拖得越久,成本不是线性涨,而是指数爆炸。
  1. P 本金第一次发现“这里设计不对”时,返工所需的工时。它像一笔贷款的本金,也是你唯一能“当时结清”的机会。
    P=当下返工工时P = \text{当下返工工时}
  2. (1+r)^t 复利因子r 是每个迭代周期债务恶化的速度,t 是拖欠的周期数。(1+r) 连乘 t 次,就是利滚利的魔力。
    (1+r)t=(1+r)×(1+r)×⋯×(1+r)(1+r)^t = (1+r) \times (1+r) \times \cdots \times (1+r)
  3. 整体含义第 1 个迭代欠 5 小时的债,拖到第 24 个迭代可能变成 80 小时。“以后再说”是最贵的四个字。
    Ct=C0×(1+r)tC_t = C_0 \times (1+r)^t

质量防线:装一台自动打压机

装修验收讲究“打压测试”和“闭水试验”:水管接好,通高压水看漏不漏;防水做完,放水泡两天看楼下漏不漏。肉眼看不出来,得靠仪器。Vibe Coding 项目里,这台仪器就是“持续集成”(CI)——每次代码合入,自动构建、自动测试,把问题拦在上线之前。

AI 写代码有一个致命特点:看起来对,逻辑错。它会在边界条件上翻车,会在重构时悄悄丢掉一个调用,会在并发场景里埋雷。所以质量防线的重心不是“让 AI 少犯错”——做不到,而是“让错误没机会上线”。三道防线缺一不可:第一,自动化测试,核心路径必须有测试兜底,AI 改完立刻跑;第二,持续集成,每次合入自动触发构建和测试;第三,代码审查,人盯 AI 的 diff,重点看业务逻辑而不是代码格式。

防线牢不牢,看回归覆盖率:

闭水试验漏水不可怕,可怕的是没做试验就搬进去住。Vibe Coding 项目最大的风险不是 AI 写错,而是没有一台自动打压机在每个变更后告诉你:水管漏了。

回归覆盖率=N自动化覆盖的关键路径N关键路径总数\displaystyle \text{回归覆盖率} = \frac{N_{\text{自动化覆盖的关键路径}}}{N_{\text{关键路径总数}}}
这个公式衡量的是:AI 万一改坏了东西,你的测试阵线能拦住多大比例。关键路径百发百中,边缘路径尽力而为。
  1. N 自动化覆盖的关键路径分子,指“坏一次就要命”的路径——支付、登录、数据导出——有多少条已经被自动化测试覆盖。
    Ncovered=∑有测试的关键路径N_{\text{covered}} = \sum \text{有测试的关键路径}
  2. N 关键路径总数分母,团队公认的“绝不能挂”的路径数量。这个名单由人来定,AI 负责补充候选,人来做主。
    Ntotal=关键路径总条数N_{\text{total}} = \text{关键路径总条数}
  3. 整体含义覆盖率不是越高越好,而是关键路径上趋近 100%。给 AI 配一百个测按钮颜色的用例,不如十个覆盖核心交易的用例。
    回归风险=1−NcoveredNtotal\text{回归风险} = 1 - \frac{N_{\text{covered}}}{N_{\text{total}}}

团队协作:让知识长在团队里

一个家要住得舒服,东西得放在所有人都找得到的地方。厨房的调料瓶有固定位置,新来的家庭成员也能在 30 秒内找到。Vibe Coding 团队最需要的不是“每个人都会写代码”,而是“每个人都知道东西放在哪儿”——包括它为什么放在那儿。

AI 加入后,团队里多了一个“最勤快的初级工”:它不知道项目历史、不懂客户约定,但它快、便宜、不知疲倦。好的协作模式是人机分工:AI 负责生成和重构骨架,人负责定义标准、审查逻辑、确认边界、决定方向。落地上有四件事——共享规范:格式化、命名、提交信息统一约定,AI 和人守同一套规矩;人机分工:AI 出草稿,人出裁决;知识共享:每次踩坑的结论必须写进知识库;审查文化:review 不盯格式,盯“这个 diff 会不会让下一个人迷路”。

团队的健康度,可以看一个代理指标——知识共享率:

厨房乱不乱,看的是有没有“调料瓶固定位”。团队协作的本质不是要求每个人都聪明,而是把聪明变成制度,把经验变成条目,把默契变成文字。

R共享=K已沉淀K总量\displaystyle R_{\text{共享}} = \frac{K_{\text{已沉淀}}}{K_{\text{总量}}}
分子是被写进文档、注释、规范、脚本里的知识,分母是团队所有成员脑子里的知识总和。这个比值越高,团队对任何个体离开的免疫力越强。
  1. K 已沉淀分子,已经变成文字、代码规范、自动化脚本、录屏视频的知识。它不依赖任何人的记忆,断电也丢不了。
    K沉淀=∑文档知识量+∑脚本知识量K_{\text{沉淀}} = \sum \text{文档知识量} + \sum \text{脚本知识量}
  2. K 总量分母,包含所有人脑中没写出来的经验——那些“老张知道”“小李懂”的隐性知识。隐性知识占比越大,分母越大,共享率越低。
    K总=K已沉淀+K隐性K_{\text{总}} = K_{\text{已沉淀}} + K_{\text{隐性}}
  3. 整体含义共享率越高,新人上手越快,协作摩擦越小,AI 能借助的上下文也越多——因为 AI 读不到人类的脑子,只能读你写下来的东西。
    R↑⇒协作成本↓R \uparrow \Rightarrow \text{协作成本} \downarrow

人员延续:接力棒要拿得住

再好的装修队也有撤场的一天。第一个师傅手艺好、干得快,但从不做交接笔记;第二个师傅进场,绕着房子转三圈,不知道配电箱的线路怎么走,只好拆墙排查。Vibe Coding 项目里有一个被放大的风险:上一任开发者一走,他开过的 AI 会话也随之“失忆”,项目瞬间变成黑盒。

人员延续的关键不是留住人,而是让知识离开人也能活。衡量这种安全感有个经典指标——Bus Factor(巴士系数):

三条落地策略:交接文档——离职前两周就让 AI 辅助生成《项目运行手册》,覆盖部署、坑位、负责人;轮岗制度——核心模块至少两个人轮流维护,禁止“一个人的后花园”;新人上手路径——把 onboarding 做成清单,新人配一个基于项目知识库的 AI 助手,一周内跑通。

接力赛最怕掉棒。项目维护的本质,就是让接力棒(知识)在人和 AI 之间稳稳传递,而不是永远挂在某个人脖子上。

B=K项目总知识K单一成员独有知识\displaystyle B = \frac{K_{\text{项目总知识}}}{K_{\text{单一成员独有知识}}}
通俗地说:如果最懂项目的那个人被巴士撞了(比喻离职、失联),项目还剩多少知识?分母越小,比值越大,项目越安全;比值接近 1,意味着一个人走了,项目就归零。
  1. K 项目总知识分子,理解这个项目所需的全部业务规则、技术决策、坑位地图。
    K总=业务知识+技术知识+过程知识K_{\text{总}} = \text{业务知识} + \text{技术知识} + \text{过程知识}
  2. K 单一成员独有知识分母,只存在于某个成员脑中、从没写下来的部分。一个模块只有小张碰过,那这个模块的知识就全部挂在分母上。
    K独有=K总−K团队共享K_{\text{独有}} = K_{\text{总}} - K_{\text{团队共享}}
  3. 整体含义Bus Factor 是通过除法把“知识集中度”变成一个数。它越接近 1 越危险;通过文档、结对、轮岗把分母变小,这个数变大,项目就扛得住变动。
    B↑⇒项目脆弱性↓B \uparrow \Rightarrow \text{项目脆弱性} \downarrow

AI 应用场景

技术债体检助手

阶段:项目维护阶段(代码库持续分析)

解决的问题:传统方式靠人工 code review 找技术债,慢且依赖个人经验。AI 扫描代码库后,按“偿还成本 = P × (1+r)^t”模型自动给模块标注债务等级和偿还顺序,把“看不见的隐蔽工程”变成一张可见的体检表。

具体案例:某支付团队每周一上午跑一次 AI 体检:扫描最近四周的代码变更,标记出“修改频率高 × 结构复杂度高”的热点模块,自动生成技术债看板;S 级债务自动排进下个迭代,团队再也不用靠“感觉”决定先重构哪里。

文档持续维护员

阶段:代码变更后的文档同步

解决的问题:README 和 ADR 永远是过期的——人写完就没空改。AI Agent 监听合并请求(PR)合并事件,自动对比代码变更与文档差异,生成文档更新建议,人只需一键确认,相当于给房子配了一位自动补画图纸的助手。

具体案例:一个 Vibe Coding 创业团队给 AI Agent 配了“文档维护”技能:每次 PR 合并后,Agent 自动更新 README 中的快速开始部分、把新增依赖记入 ADR、把新踩的坑写进 wiki。三个月后,文档新鲜度从 60% 提升到 95%,新人上手时间缩短一半。

新人陪跑教练

阶段:知识传承与团队培训

解决的问题:新人上手要“考古式”读代码三个月,而 Vibe Coding 项目里代码注释往往不够。AI 助手结合项目文档、ADR 和代码索引,为新人提供问答式引导,相当于给每个新人配了一位熟悉整栋房子管线的老管家。

具体案例:某公司让新人用一个基于项目知识库的 AI 助手:问“订单号从哪传进来”时,助手根据 ADR 和代码调用链给出带依据的答案,配合轮岗清单,新人在三周内达到可独立改代码的水平,比传统路径提速一倍。

Python 演示

python29 行
def simulate_debt(principal=100, rate=0.08, months=24, pay_ratio=0.15):    """Simulate two tech-debt strategies: ignore vs monthly payoff."""    # 策略一: 不治理, 债滚债    unmanaged = principal    # 策略二: 每个月主动还掉当前债务的 pay_ratio    managed = principal    records = []    for m in range(months):        unmanaged *= 1 + rate          # 利息按月复利        managed *= 1 + rate            # 利息照付...        managed -= managed * pay_ratio # ...但每月还一部分        records.append((m + 1, unmanaged, managed))    return records  def main():    records = simulate_debt()    print("Month | Unmanaged | Managed")    for month, unmanaged, managed in records:        if month % 4 == 0 or month == records[-1][0]:            print(f"{month:>5} | {unmanaged:>9.2f} | {managed:>9.2f}")    last = records[-1]    ratio = last[1] / last[2]    print(f"Result: {last[0]} months later, unmanaged debt is "          f"{ratio:.1f}x of managed debt.")  if __name__ == "__main__":    main()
目的:用最简单的复利模型模拟两条技术债路径——不治理 vs 每月偿还 15%,直观看到第 24 个月时差距达到数十倍。
  1. def simulate_debt(principal=100, rate=0.08, months=24, pay_ratio=0.15)定义模拟函数,本金 100 个工时、月息 8%、观察 24 个迭代、每月偿还当前债务的 15%。
  2. unmanaged *= 1 + rate不治理时,债务每个月按利息率滚动,这就是公式里的 (1+r)^t 在逐月累乘。
  3. managed -= managed * pay_ratio治理策略每月还掉当前债务的 15%,像还房贷一样固定分期,让债越滚越小。
  4. records.append((m + 1, unmanaged, managed))把每个月的两条债务都记下来,留作后续对比和画曲线。
  5. ratio = last[1] / last[2]用第 24 个月的数据相除,算出两种策略的倍数差距,直观感受复利的破坏力。

常见误区

误区每次写完功能,再让 AI 读一遍它就能改,所以注释没必要写,写注释纯属浪费时间。

正解AI 在多个会话之间是“失忆”的——新会话里它对这段代码的了解程度和新人一样低。注释是把上下文从“某个会话的临时记忆”搬到“代码旁边”的唯一方式。而且注释是给未来的 AI 和同事看的,不是给当时那个会话看的。每少一句“为什么”,下一次修改就要多花十分钟考古。

为何常见:因为 Vibe Coding 的体验是“即时可改”,让人误以为 AI 永远记得上下文,忽略了会话结束即清零的事实。

误区先把需求都做完,测试、重构、文档都攒着,等项目稳定一点再一次性处理。

正解技术债是按复利增长的。拖一个迭代,借 5 小时的债可能变成 8 小时;拖十个迭代,它就变成 80 小时。“统一还债”在复利模型下是最昂贵的策略,正确做法是每个迭代固定投入 20% 工时“分期还”,像还房贷一样雷打不动。

为何常见:人脑对线性增长直觉强烈,对指数增长无感;而紧迫的功能需求永远压过不紧急的技术债。

误区项目结构乱了,干脆开一个新会话,让 AI 理解全部代码,然后从头重写一遍。

正解大爆炸式重构等于把承重墙全部砸掉重砌——AI 无法理解全部业务约束,重写后必然丢失隐性逻辑。正确路径是模块化小步重构:先加测试锁住行为,再逐模块重写,每步都能回归验证。拆隔断墙可以快,拆承重墙必须慢。

为何常见:Vibe Coding 让“重写代码”的成本看起来极低,但“重写业务理解”的成本依然极高,人们低估了隐性逻辑的价值。

误区反正代码是 AI 写的,只要代码还在,以后让 AI 继续改就行,人走了也不怕。

正解AI 不持有业务记忆。代码在,但“为什么这么做”“哪些地方是临时方案”“对哪个客户有特殊承诺”这些背景知识全在人的脑中。如果这些没有沉淀成文档和 ADR,人一走,AI 也只能对着一堆“看得懂却讲不清动机”的代码瞎猜。

为何常见:人们把“AI 会写代码”和“AI 懂这个项目”混为一谈,忽略了上下文与业务知识根本不在代码里。

误区AI 写的代码风格统一、语法正确,比人写的还规整,review 纯属形式。

正解AI 的错误恰恰藏在“看起来正确”里:边界条件漏判、并发安全缺失、业务规则微妙误解。代码审查是质量防线的最后一道闸,重点不是挑格式,而是验证“这个 diff 的行为是否符合业务预期”。格式可以交给工具,逻辑必须交给人类。

为何常见:因为 AI 输出确实在格式层面很完美,让人误以为形式正确等于逻辑正确。

面试题

Q1. 在“AI 装修工盖房子”的比喻中,技术债最像以下哪一项?

单选题 · easy

  • A.承重墙的结构设计
  • B.墙里没埋管的电线← 正确答案
  • C.客厅里的装饰沙发
  • D.大门上贴的门牌号

答案:B。技术债像“隐蔽工程”——埋进墙里的水管电线,装好时看不见,出问题要砸墙。承重墙是架构设计,沙发和门牌是表面装饰,都不符合“看不见却后患无穷”的特征。

Q2. 技术债复利模型 P×(1+r)^t 中,符号 t 代表什么?

单选题 · mid

  • A.项目代码总行数
  • B.团队成员的个数
  • C.拖延偿还的周期数← 正确答案
  • D.自动化测试覆盖率

答案:C。t 是拖欠债务的迭代周期数,它是复利公式里的“时间指数”。代码行数、团队人数、测试覆盖率都与该模型中的 t 无关,t 只描述“拖了多久”。

Q3. ADR(架构决策记录)的核心作用是记录什么?

单选题 · mid

  • A.每天代码行数的统计
  • B.为什么做出这个设计← 正确答案
  • C.所有历史版本的备份
  • D.每个成员的代码贡献

答案:B。ADR 记录的是“当时为什么选这个方案”的决策依据,它是给未来的 AI 和同事看的说明书。它不是统计工具,不是备份系统,也不是绩效记录。

Q4. Bus Factor 公式中,分母表示以下哪一项?

单选题 · extreme

  • A.团队中的总人数
  • B.项目所需知识总量
  • C.个人掌握的独有知识量← 正确答案
  • D.核心模块的测试用例数

答案:C。Bus Factor = 项目总知识 ÷ 单一成员独有知识。分母是“只存在于某个人脑中、没沉淀下来”的知识量。分母越大,比值越接近 1,项目越脆弱;通过文档和轮岗让分母变小,项目才安全。

Q5. “守住项目的承重墙”在维护策略中指什么?

单选题 · easy

  • A.保护核心模块的边界不破坏← 正确答案
  • B.禁止修改任何一行代码
  • C.把所有模块放进一个文件
  • D.让 AI 每次重写整个代码库

答案:A。承重墙比喻核心模块和关键边界——不能随意破坏,但不等于不能修改。选项 B 过于极端,C 和 D 恰恰是破坏架构的做法。

Q6. 回归覆盖率在维护中的定位是什么?

单选题 · hard

  • A.提升代码运行时的性能
  • B.在 AI 改坏功能时及时拦截← 正确答案
  • C.替代代码审查与同行评审
  • D.自动生成用户操作手册

答案:B。回归覆盖率衡量自动化测试能拦住多少“改坏已有功能”的场景,它是 CI 防线的一部分。它不提升性能,不能替代人的逻辑审查,也不生成用户手册。

Q7. 下列哪些做法能有效降低关键人风险?

多选题 · mid

  • A.离开前补齐交接文档← 正确答案
  • B.核心模块定期轮岗维护← 正确答案
  • C.代码库启用加密存储
  • D.重要决策写入 ADR 记录← 正确答案

答案:ABD。交接文档让独有知识变共享,轮岗让“一个人的后花园”变成两个人的,ADR 把决策依据留在仓库里。加密存储只保护代码不被偷,不解决知识垄断问题。

Q8. 关于 Vibe Coding 的代码审查,正确的观点有哪些?

多选题 · mid

  • A.AI 生成的代码同样需要审查← 正确答案
  • B.审查重点查逻辑而非格式← 正确答案
  • C.格式统一可交给工具自动处理← 正确答案
  • D.审查没必要因为 AI 代码稳定

答案:ABC。AI 的错误藏在“看起来正确”的逻辑里,所以 AI 代码更需要人审;格式问题交给格式化工具即可。D 把“形式稳定”误当成“逻辑正确”,正是最危险的误区。

Q9. 团队知识共享率升高,最直接的好处是什么?

单选题 · hard

  • A.单个成员离职的影响变小← 正确答案
  • B.AI 上下文窗口变得更大
  • C.代码编译速度自动提升
  • D.团队成员人数自动减少

答案:A。共享率 = 已沉淀知识 ÷ 总知识,它越高说明越多知识离开个人也能活,所以单点离职的影响变小。它与 AI 的上下文窗口、编译速度、人数都没有直接关系。

Q10. 下列哪些属于文档建设的重要内容?

多选题 · easy

  • A.代码注释书写规范← 正确答案
  • B.README 随版本更新← 正确答案
  • C.架构决策记录 ADR← 正确答案
  • D.服务器登录密码表

答案:ABC。注释规范、README 维护、ADR 决策记录是文档建设的三大支柱,都是为了对抗 AI 的“失忆”特性。密码表属于安全信息管理,不属于文档建设。