生成式软件工程:从需求、架构到 Agent-native 开发
生成式软件工程:从需求、架构到 Agent-native 开发
前言:为什么今天仍然需要学习软件工程
生成式 AI 正在改变软件开发的基本方式。过去,开发者需要亲自完成需求分析、系统设计、编码、测试和维护;现在,我们可以把其中相当一部分工作交给模型和 Agent。模型能够生成代码、操作浏览器、调用工具、运行测试,甚至并行承担多个开发任务。然而,代码生成成本下降,并不意味着软件工程问题消失了。真正困难的部分仍然是:我究竟想要什么,应该怎样准确描述它,如何把它分解成可以实现的系统,以及怎样确认最终结果符合预期。
我把本教程的核心问题概括为三个相互关联的环节:需求如何从人的意图变成明确的规格,架构如何把复杂问题分解成可管理的结构,质量保障又如何证明实现没有偏离规格。 Agent 只是改变了这些工作的执行者和协作方式,并没有取消这些问题。理解软件工程的历史和基本原理,能够帮助我更有效地组织 Agent,也能让我在模型生成大量代码时仍然掌握系统的方向。
本教程按照知识之间的依赖关系组织内容。首先回顾软件工程为什么诞生,以及软件开发中长期存在的意图、规格和实现之间的差距;随后讨论需求工程、架构设计和复杂性管理;接着介绍 Agent-native 开发与 DeepSeek Harness 的架构思想;最后通过软件演化、测试、调试和形式化方法,建立一套从构想到交付、从实现到验证的完整工作方式。
软件工程的起点:从人的意图到可维护的软件
生成式 AI 改变了什么
生成式 AI 的发展速度非常快。课堂中回顾的技术脉络,从 20 世纪 50 年代人工智能研究走出实验室,到 70 年代至 90 年代的人工智能寒冬,再到 1997 年搜索算法击败人类世界冠军、2012 年 AlexNet 带来的深度学习突破,以及 2016 年前后强化学习和深度神经网络引发的关注,最终延伸到 Transformer、BERT、大规模语言模型、多模态模型和视频生成模型。2020 年 GPT-3 展示了大规模预训练的能力,2022 年 ChatGPT 让更多人直观感受到大语言模型的用途,随后模型逐步具备图像理解、语音交互和视频生成能力。技术演进的周期不断缩短,许多过去需要多年研究才能实现的能力,今天可能在很短时间内就成为普通产品的一部分。
这种变化不仅体现在模型能生成什么,也体现在模型响应得有多快。传统大模型能够完成复杂推理,但生成过程可能存在明显延迟;如果有一个足够小、能够在几十到几百毫秒内作出决策的模型,它就可以承担实时控制任务。例如,模型可以根据游戏状态选择下一步动作,也可以根据对话内容实时调整数字人的微表情和动作。实时决策能力使 AI 从“回答问题的系统”逐渐变成“感知环境并持续采取行动的系统”。这类能力可以用于游戏、机器人、数字人以及与物理设备交互的场景。
我也需要看到模型能力提升背后的局限。模型可能非常擅长服从提示词,却不一定具备判断下一步应该做什么的长期直觉。它可能为了尽快获得奖励,采用最快但质量不高的办法完成任务,这种倾向可以理解为一种 reward hacking。任务在短期内完成了,不代表产物符合长期维护、可扩展性和整体设计的要求。因此,模型的“品位”不仅是输出是否漂亮,还包括它能否判断什么值得做、什么应该暂缓,以及眼前的局部收益是否会损害系统的长期目标。
可验证性也存在边界。数学似乎比品位更容易验证,但形式化证明并不能自动消除问题:自然语言描述的问题必须先被翻译成形式语言,而这一步仍然可能出现偏差。如果形式化定义本身把原问题改成了一个过于简单甚至没有意义的问题,那么后续证明即使完全正确,也不能证明原来的问题。换句话说,验证一个形式系统内部的推理,与确认这个形式系统准确表达了人的意图,是两件不同的事情。
数据分布工程与持续扩展的模型能力
我认为,大模型能力提升不只是参数规模和训练数据数量的增长,还涉及训练数据分布的组织方式。一个已经具备语言、数学、编程和视觉能力的基础模型,再学习一个新的领域时,可能不需要从零开始,也不一定需要与从零训练相同规模的数据。它已有的知识、抽象能力和推理能力,可能帮助它更有效地吸收新领域的信息。基础模型训练阶段的数据分布、后训练阶段的反馈信号,以及强化学习如何评价不同输出,都会影响模型最终形成的能力。
这与人类的学习顺序并不完全相同。人通常先通过与物理世界交互形成世界模型,之后逐渐学习语言、数学和专业知识;大模型的训练顺序则可能先从语言开始,再扩展到数学、视觉和空间理解。不同训练顺序最终都可能形成强大的能力,这说明数据分布、训练阶段和反馈机制本身值得研究。对于一个已有良好基础能力的模型,新的领域可能像一个可插入的能力模块:只要这个领域能提供足够清晰的反馈,模型就可能在该领域建立新的学习闭环。
更进一步,如果模型能够帮助研究者发现新领域、设计实验、分析结果并优化训练数据,就可能形成递归自我改进(Recursive Self-Improvement,RSI)的循环。生物工程、化学实验、情感计算和动物行为预测,都可能成为新的能力扩展方向。这样的闭环一旦逐渐成熟,模型能力就可能随着新领域和新实验设施的加入而持续提高。它也会改变学术研究和软件行业的工作方式:小规模实验仍然有价值,但大型模型团队可能拥有更完整的数据、算力和反馈循环;有些研究成果即使不以论文形式出现,也可能通过博客、开源项目或实验报告被更大规模的系统吸收。
这些变化带来就业压力,也带来新的机会。人类社会始终存在竞争,能力门槛会随着技术发展不断提高。我不能因为模型已经能写代码,就放弃理解需求、架构和质量的能力。相反,越是能够使用 Agent,越需要判断它是否做对了事情,是否采用了合理的设计,以及是否真正完成了任务。
软件工程面对的根本差距
软件开发的根本困难,可以用三个概念来描述:Intent、Specification 和 Implementation。Intent 是人的意图,也就是我真正想要什么;Specification 是对意图的明确描述,包括系统应该做什么、不能做什么,以及在不同条件下应该如何表现;Implementation 是最终的程序、数据结构、接口和运行逻辑。软件工程之所以困难,是因为这三个层次之间始终存在差距。
人的意图通常是模糊的、上下文相关的,而且会随着时间变化。即使我认为自己已经想清楚了需求,也可能没有想到边界情况;即使需求已经写成文档,不同的人仍可能对同一句话产生不同理解;即使规格已经足够明确,实现也可能因为设计或编码错误而偏离规格。软件工程需要建立一套方法,让这些差距尽早暴露、逐步缩小,并且在系统长期演化时仍然能够追溯。
我可以把软件中的需求、设计、模块、函数、代码和测试看成一个相互依赖的网络。后面的实现依赖前面的规格,测试依赖设计和代码,维护又依赖过去的决策。如果后期发现一个测试失败,问题可能并不在测试本身,而是实现、设计,甚至最初的需求理解出了错。越晚发现问题,需要回溯和修改的部分就越多,成本也越高。这就是软件工程要解决的核心问题之一:如何管理这些依赖,避免一个早期错误在后续阶段不断扩大。
软件为什么并不像名字所说的那么“软”
物理世界中的材料通常有一定弹性和容错空间。椅背受到压力后可能变形,压力消失后又恢复原状;软件则是逻辑制品,对细微错误往往非常敏感。一个比特翻转、一个整数溢出、一次错误的内存覆盖,都可能让程序进入完全不同的状态。假设程序原本读入一个很小的整数,某个硬件错误却让它的最高位发生翻转,程序就可能把这个值解释成一个极大的数字,进而执行错误的循环、访问错误的内存,甚至一直运行下去。
这并不只是极端环境中的问题。高密度芯片、热噪声、硬件制造缺陷和长时间运行,都可能带来难以预测的错误。软件必须运行在真实的硬件、网络和组织环境中,因此它不仅要满足理想情况下的逻辑要求,还要考虑异常、失败和恢复。软件工程不能只研究怎样把代码写出来,还要研究怎样让软件在不完美的环境中保持可用、可维护和可演化。
软件工程为何在 20 世纪 60 年代成为独立问题
回到 1960 年前后,计算机硬件非常昂贵,往往需要占据很大的空间,制造成本也很高。早期程序员同样昂贵,因为编程工具并不成熟,开发者需要直接面对机器代码、汇编语言和非常有限的运行环境。为了避免在低层代码中迷失,程序员需要先画流程图,明确控制流程,再把逻辑翻译成机器能够执行的指令。今天看来,这些步骤可能显得繁琐,但在当时,它们是降低复杂性的必要手段。
客户和程序员之间也存在巨大的认知差距。客户可能知道自己想要一个跨时代的计算机系统,却不了解计算机实际能做什么;程序员则可能只熟悉汇编、控制流和机器限制。20 世纪 60 年代的科普杂志已经开始描绘计算机辅助教学、即时判分和个性化辅导等未来场景,但许多设想在很长时间里都没有真正实现。客户的想象与程序员的实现能力之间存在明显鸿沟,软件企业必须承担把客户意图转化为技术实现的责任。
软件需求与桥梁、炼钢等传统工程有一个重要区别。传统工程面对的物理约束相对稳定:材料强度、建筑高度、承载能力和自然规律不会因为客户的一句话而改变。软件的需求则高度定制化,往往来自人的偏好、组织规则和社会制度。一个选课系统不仅要处理课程和学生,还要考虑课程容量、先修要求、时间冲突、专业限制、审批权限以及各种例外。需求本身可能尚未被客户完全想清楚,因此软件工程不仅要实现需求,还要帮助客户发现和澄清需求。
可读性、可维护性与 Dijkstra 的警告
软件工程的目标不只是让程序运行一次,还要让其他人能够理解、修改和维护它。Dijkstra 关于 goto 语句的讨论,核心并不是说任何 goto 都绝对有害,而是提醒程序员:控制流如果过于随意,程序就会变得难以理解。大量无约束的跳转会让读者很难判断程序从哪里来、接下来会到哪里去,也就增加了维护成本。
不过,具体语言和工程实践中也存在合理的局部用法。例如,Linux 内核中的某些 C 代码会使用 goto release,把资源释放集中到一个出口。函数中间如果发生错误,就跳转到统一的释放逻辑,逐项检查并释放已经申请的资源。这种受约束的用法反而能减少资源泄漏。真正需要避免的不是某个语法结构本身,而是缺乏清晰规则、破坏可读性的控制流。
Dijkstra 在 1972 年的图灵奖演讲《The Humble Programmer》中讨论了软件危机的根源。机器越来越强,软件承担的现实任务也越来越多,需求随之膨胀,程序复杂度和维护成本不断提高。一个只完成一次计算的小程序,调试完成后可能不需要继续维护;但一个长期运行、不断扩展的软件系统,必须面对持续变化的需求。因此,软件需要良好的分解方式,也就是 nicely factored solutions。Dijkstra 还指出,软件领域的保守力量往往来自教育机构,以及不愿意重写旧程序的用户。这些观察放到今天仍然成立。
Apollo 软件工程与防御性设计
软件工程成为一门学科,与大型、高风险项目中的失败经验密切相关。1968 年 NATO 软件工程会议通常被视为软件工程学科形成过程中的重要节点。同期,Margaret Hamilton 及其团队在 Apollo 项目中实践了大量严谨的软件工程方法。航天任务要求软件在异常情况下仍然能够维持关键功能,因此工程师不能简单假设某些错误“永远不会发生”。
我把这种思想概括为:Never going to happen can happen。 看起来不可能发生的事情,也必须进入设计和验证的考虑范围。硬件可能不可靠,输入可能超出预期,程序可能发生异常;即使某个非关键任务失败,系统也应该尽可能让关键任务继续运行。Apollo 11 登月下降过程中曾出现警报,软件通过任务优先级和恢复机制,使关键的下降控制任务得以继续。这体现了防御性编程的核心思想:不能只设计正常路径,还要设计异常发生时系统如何恢复。
软件工程的定义与生命周期
软件工程可以理解为一种系统化、规范化、可量化的方法,用于软件的开发、运行和维护。它不是个人英雄主义,而是把复杂的软件工作变成可分解、可协作、可检查的工程过程。一个成熟的软件项目需要明确需求、设计系统、组织实现、验证质量、交付产品,并在运行过程中持续维护。检查清单、评审、文档、测试和项目管理都属于软件工程,因为它们共同降低了项目失败的概率。
我尤其强调检查清单的价值。对于习惯独立完成算法题的人来说,检查清单可能显得机械,但在真实项目中,它能提醒团队完成容易遗漏的工作,例如确认需求是否与客户沟通、接口是否一致、文档是否更新、异常路径是否处理。它不一定包含代码,却能减少人的疏忽和认知偏差。只要一个项目需要多人协作,检查清单就可能成为非常有效的工程工具。
瀑布模型的原始出处:Royce 真正想表达什么
Winston Royce 在 1970 年发表的《Managing the Development of Large Software Systems》是软件工程史上的经典文章。今天许多教材用需求分析、系统设计、编码、测试和交付的顺序图来介绍瀑布模型,但这篇文章并不是简单地鼓吹严格的单向瀑布流程。恰恰相反,Royce 分析了这种流程为什么容易失败,并提出了提前验证和重复设计的办法。
瀑布式流程的问题在于,测试往往是整个开发链条中第一个真正发生的物理事件。在需求、设计和文档阶段,许多内容只是文字和图表;程序真正运行起来以后,团队才会看到实际行为。如果 Intent、Specification 和 Implementation 在前面已经发生漂移,那么等到测试阶段才发现问题,就意味着必须回头修改需求、设计和实现。修改越靠前,影响范围往往越大,返工成本也越高。
Royce 提出的一个重要思路是 Doing it twice。在投入完整实现之前,先做一个不完备但能够体现系统核心功能的初步试验程序,也可以理解为 preliminary pilot program。这个试验版本可能会失败,但它的成本较低,能够帮助团队验证关键假设,发现设计中的问题,再据此修订正式系统。今天我们通常用 MVP(Minimum Viable Product,最小可行产品)来表达相近的思想。
MVP、敏捷开发与 TDD:尽早获得真实反馈
MVP 不是随便做一个粗糙的产品,而是选择最少的功能,尽可能接近最终产品的核心价值,用最低成本验证最重要的假设。做得越多,可能犯错的地方越多;先实现一个小而完整的核心路径,能够帮助我确认用户真正需要什么、系统设计是否合理,以及技术方案能否成立。对于 AI 辅助开发来说,早期原型的实现成本更低,因此可以更频繁地生成、试用、丢弃和重做。
我曾用 AI 快速实现过一个与物理设备交互的小工具。办公室里有扫描仪、标签打印机等设备,每个设备原本都要求用户安装厂商提供的软件,而这些软件体验并不好。我希望把设备统一抽象成更容易使用的接口:扫描仪提供一个 scan 操作,参数描述扫描面朝向、单面或双面、分辨率等;打印机提供一个 print 操作,输入图像即可打印。这样,上层应用只需要依赖稳定、简洁的接口,不必直接处理每个厂商的软件细节。
这个例子体现了软件工程中的抽象和接口设计。操作系统课程中,设备驱动通常把设备抽象为 read、write、I/O control 等操作;我在应用层进一步把它包装成更符合实际任务的接口。扫描仪和打印机的具体实现可以变化,上层流程却不需要随之改变。接口一旦设计好,设备实现与业务逻辑就被解耦了。
实际开发中,标签打印机并不是完全标准化的设备。它使用热转印方式,通过加热碳带把图像转印到标签上,其中有一个影响打印深浅的参数。最初我并不知道这个参数应该设成多少,于是让模型反复打印带有编号的测试标签,再由我判断结果偏淡还是偏浓。后来我让模型尝试使用通用 PCL 打印驱动,把设备当成普通打印机处理。如果再接入摄像头,模型甚至可以自己观察每次打印结果,调整参数并继续试验,形成一个自动反馈闭环。
同样的思路也可以用于扫描仪和其他设备。我的目标不是为每个设备重新学习一套难用的软件,而是建立一个统一抽象,让上层工具按照任务调用设备。今天的 AI 已经可以帮助我逆向设备协议、理解驱动、生成接口和调试参数。比如电子墨水屏设备可能只有一个难用的 Android 应用,但如果它使用标准蓝牙协议,我可以分析 APK、逆向蓝牙通信过程,再实现自己的控制程序。
Doubao Phone 一类产品体现了另一种抽象:传统 App 是给人操作的界面,而 Agent 可能直接通过 API 或 Computer Use 调用服务。用户说“帮我点外卖”,Agent 就把外卖应用当成一个完成任务的接口;查询、填写和提交等操作都可以由 Agent 组织。应用本身未必消失,但它面向的主要调用者可能从人转向 Agent。软件产品的价值会逐渐从“提供一套人工操作界面”转向“提供可靠的能力接口”。
敏捷开发可以看作把 Doing it twice 推广为反复迭代。第一个版本甚至可以只是一个能够运行的 Hello World,或者让每个模块都能启动并报告自己的状态。关键是先把最重要的依赖关系和端到端流程打通,再逐步扩展功能。TDD(Test-Driven Development,测试驱动开发)则把反馈进一步提前:先写测试,明确输入和预期输出,再实现满足测试的代码。无论采用 MVP、敏捷开发还是 TDD,背后的共同原则都是让关键假设尽早遇到证据。
用数据依赖图理解返工成本
我可以把需求、设计、代码和测试看成一个有向无环的数据依赖图。需求中的一个决定可能影响多个设计;一个设计又可能影响多个模块、函数和测试。依赖关系会沿着系统传播,因此后期发现某个基础设计错误时,所有依赖它的产物都可能需要修改。
这也解释了为什么我不应该一开始就深入实现所有细节。可以先采用宽度优先的方式,把核心路径的第一层模块建立起来,再逐层补充;也可以在关键路径走通以后,对某个模块进行深度迭代。MVP 和敏捷开发就是这种策略的实践:先保证重要依赖链能够运行,再逐步扩展。每一次迭代都应该让不确定性减少,而不是让代码量无目的地增加。
软件工程工具如何缩小意图与实现之间的差距
软件工程在不同阶段使用不同的表达工具。需求阶段可能使用自然语言和用户故事;设计阶段需要结构化的设计文档、流程图、决策表和模型;实现阶段使用编程语言;测试阶段则使用测试用例、断言和自动化工具。工具的形式化程度逐渐提高,是为了减少不同阶段之间的语义漂移。
检查清单虽然通常以自然语言写成,但它有固定格式,每一项都要求明确检查或确认,因此比随意写一段说明更容易对齐。决策表可以把不同条件和对应行为列清楚,避免遗漏组合情况。文档之间的交叉审查则有助于发现需求、设计和测试之间的不一致。对于大型项目,需求追踪矩阵(Traceability Matrix)要求需求点、设计元素、代码和测试之间建立对应关系,使团队能够回答:某个功能由哪些设计实现?某个测试验证哪条需求?修改一个设计会影响哪些模块和测试?
QuickCheck 等性质测试工具进一步把测试从手写样例扩展为“描述性质、自动生成输入、寻找反例”。开发者描述程序应该满足的性质,工具生成大量输入并检查是否存在违反性质的情况。这种方式特别适合那些输入空间很大、很难手工穷举的程序。
面向契约的设计(Design by Contract)则尝试把前置条件和后置条件写进程序结构。Eiffel 语言是这一思路的重要代表:函数可以声明 require 前置条件、执行实现,并通过 ensure 声明后置条件。这样,模块的责任就不再只存在于自然语言文档中,而是能够以更明确的形式被检查。UML(Unified Modeling Language,统一建模语言)则试图在需求、设计和实现之间提供一种共同的建模语言,帮助团队对齐对象、关系、行为和系统结构。
UML 的目标很有野心:不同人听到同一句自然语言时,脑海中可能出现不同的图景;即使我说“一个美女”,不同人的想象也不会完全相同。数学语言之所以更容易对齐,是因为它从明确的公理和定义出发,语义相对确定。UML 希望把能够明确表达的部分固定下来,同时承认仍有一些意图无法完全形式化。它不是消除所有歧义,而是帮助团队区分哪些语义必须确定、哪些部分仍需要讨论。
需求工程:理解用户、业务与社会规则
需求不只是功能列表
需求工程的工作,是通过持续沟通和观察,弄清楚客户真正需要什么。需求可能小到界面上是否显示当前学期和学年、某个位置是否需要修改按钮,也可能大到整个学校从入学到毕业的业务流程。需求文档不是把客户说过的话机械记录下来,而是要把用户的工作方式、业务规则、权限边界、数据来源、异常情况和验收标准整理清楚。
我尤其需要区分客户和最终用户。提出需求的人可能是管理者,实际使用系统的人却可能是教务员、教师或学生。设计者不能假设所有用户都像程序员一样熟悉计算机。例如,一位已经工作多年、即将退休的教务人员,可能并不习惯复杂的操作流程;年轻教师和学生则可能期待更灵活的交互方式。系统必须服务真实用户,而不是服务开发者对“理想用户”的想象。
在一个教学服务平台中,需求可能包括从入学到毕业的完整业务过程,也包括权限规则、版本数据同步和操作留痕。教师端的需求又与学生端不同。通过浏览器实际操作系统,我可以逆向梳理教师相关功能,形成需求规格说明书。但这只是需求分析的起点,不代表整个系统的设计已经完成。
需求中的例外比表面流程更复杂
以选课系统为例,表面上看,系统只需要让学生选择课程;实际上,选课涉及课程容量、先修课程、时间冲突、专业限制、教室安排、教师安排和学期规则。先修课究竟是硬性限制还是软性限制?谁有权限覆盖限制?课程满员时应该排队、抽签还是为特定专业保留名额?学生不满足先修要求时,教师能否特批?这些问题都不是简单的界面设计能够解决的。
毕业审核会进一步暴露业务规则的复杂性。假设某位学生即将毕业,却因为课程开设时间变化,无法在最后一个学期修读某门必修课;又或者旧课程与新课程之间存在替代关系。系统不能只按当前数据库中的课程编号判断学生是否毕业,还要考虑学校审批、课程替代和历史记录。最终可能由教学负责人判断两门课程在培养要求上可以互相替代,再由有权限的人员完成处理。
这类例外不是系统中的“脏数据”,而是现实社会规则的一部分。软件是物理世界和社会过程在信息世界中的投影,因此不能假设所有规则都能被简化为几个固定字段。软件需求的复杂性,来自它连接了人的偏好、组织制度、业务流程和物理条件。
代码之外有客户的规律,客户之外有社会的规律
我在设计系统时,不能只站在代码内部看问题。代码之外有客户的规律,客户之外有社会的规律,社会之外还有物理世界和自然规律。比如,客户要求某个学生满足毕业条件,但架构师还要理解学校的培养制度、课程之间的关系、审批流程以及这些规则为什么存在。
如果我只把当前需求逐条实现,确实可能交付一个表面上百分之百满足需求的系统,却在未来维护中陷入长期泥潭。每一次设计决定都会形成一定程度的技术债。数据库选型、数据结构、模块边界、权限模型和状态管理方式,都会影响未来扩展的成本。架构设计的价值不只是让当前功能运行,还要尽量避免未来每次新增需求都必须修改大量旧代码。
本质复杂性与偶然复杂性
Brooks 将软件复杂性区分为本质复杂性(Essential Complexity)和偶然复杂性(Accidental Complexity)。本质复杂性来自问题本身,不能通过换一种编程语言或框架就彻底消除。例如,选课系统必须处理课程容量、先修关系和时间冲突,这些规则本来就存在于现实世界。偶然复杂性则来自不合适的实现方式、工具限制、糟糕的接口和不必要的耦合。
架构设计的任务,是承认本质复杂性,并把它组织在清晰的模块和接口中,同时尽量减少偶然复杂性。好的架构不能让现实业务变简单,却能让每个模块只承担一部分责任,让模块之间通过明确接口协作。数据库就是一个典型抽象:业务代码不必了解数据在磁盘上的具体存储方式,只需要依赖数据库提供的查询、更新、事务和持久化能力。云数据库还可能提供备份、恢复和可用性承诺,让应用开发者把注意力更多放在业务规则上。
抽象、接口与 MVC
抽象的作用,是把复杂实现隐藏在稳定接口之后。以扫描仪为例,上层系统只需要调用 scan,并传入扫描面、单双面和 DPI 等参数,不必了解设备内部如何控制电机和传感器。打印机也可以被抽象成 print(image)。当实现发生变化时,只要接口契约保持稳定,上层业务就不需要跟着修改。
MVC(Model-View-Controller)也是一种分解复杂性的方式。Model 管理数据和业务状态,View 负责呈现,Controller 负责处理用户操作并协调模型与视图。它的价值不在于名称,而在于把不同变化原因放到不同位置,避免界面、业务规则和数据存储相互纠缠。数据库、MVC 和设备驱动都体现了同一个原则:为系统的不同部分建立边界,让每个部分通过明确的接口承担有限责任。
事件溯源:把事实与当前状态分开
传统 CRUD 系统通常直接维护当前状态:创建记录、读取记录、更新记录、删除记录。对于一些业务,直接更新状态可能会丢失重要的历史信息。例如,学生当前的毕业状态可能是多个课程成绩、学分规则、课程替代和审批结果共同作用的结果。如果系统只保留最终的“已毕业”字段,就很难回答这个状态是如何产生的。
事件溯源(Event Sourcing)采用另一种思路:保存发生过的事实事件,再根据事件重建当前状态。当前状态不再是唯一的事实来源,而是历史事件经过计算后得到的投影。对于学生学分系统,我可以记录某门课程在某个时间点通过、学分是多少、课程规则何时变化、审批何时发生。当前学分和毕业资格由这些事件推导出来,因此我可以追溯某个时间点的状态,也可以解释为什么系统得出了某个结论。
如果现实世界发生了预期之外的变化,系统不必让工程师直接修改数据库中的某个结果,而是追加新的事实。例如,教学负责人批准课程替代,就追加一条审批事件,再由系统重新计算毕业状态。这样,历史记录仍然完整,当前状态也能够根据事实重新生成。事件溯源还可以支持回放和预测:如果流程当前处于“下单、锁库存、计算优惠、等待支付”的某一步,我可以根据已经发生的事件推演后续不同结果。
事件回放可能带来性能问题,因为系统需要重新处理大量历史事件。工程上可以通过快照和缓存优化,不必每次都从最初事件开始计算。事件溯源、CQRS(Command Query Responsibility Segregation)和领域驱动设计(DDD)经常一起被讨论,但它们并不是同一个概念,也不是必须捆绑使用的技术。重要的是先理解业务中哪些是事实、哪些是派生状态,再决定采用什么架构。
架构能力来自跨领域的抽象
架构能力不是记住更多框架名称,而是能够从不同知识领域中找到可迁移的结构。递归和非递归、栈和调用过程、数据库和事件日志、模块和接口,看起来属于不同课程,却都可以帮助我理解状态、依赖和抽象。以汉诺塔为例,同一个问题可以用递归、显式栈或其他方式表达。真正重要的不是某一种写法,而是我能否识别问题背后的结构,并选择适合当前目标的表示方式。
我把这种能力理解为“跳出问题看问题”。代码之外有客户规律,客户之外有社会规律,社会之外有自然规律。越能识别问题背后的稳定结构,就越能设计出简洁、可维护的系统。压缩复杂性并不意味着隐藏重要细节,而是找到一组更高层次的概念,使大量细节能够由少数原则解释。
Agent-native 开发:把开发过程组织成可管理的协作系统
从单人编程转向 Agent 团队
传统学习中,我通常把自己看作一个单线程开发者:学习 C、C++、Python 或 JavaScript,然后独立完成项目。拥有 Agent 之后,我的角色发生变化。我更像一个技术负责人或 CTO,需要明确产品目标、拆分任务、分配工作、协调多个执行者,并对最终结果负责。底层可以有负责架构、产品、前端、后端和测试的 Agent,每个 Agent 还可能继续调用子 Agent。
这并不意味着我不再需要理解软件。相反,我需要把任务拆成清晰的工作单元,并知道每个任务会影响仓库中的哪些部分。一个任务可能只是修复一个 bug,也可能重构一个子系统,或者新增一个跨模块功能。任务的范围、写入权限和潜在冲突都不同,因此 Agent 协作需要类似组织管理和资源管理的机制。
任务分解与并行协作
如果两个任务修改的模块彼此独立,就可以并行执行;如果两个任务都要修改同一份核心状态,就需要协调。可以借鉴操作系统和数据库中的锁机制:有些任务只需要读锁,有些任务需要写锁,有些任务是重构,虽然会修改代码,但不一定改变外部接口。小型 bug fix 如果彼此独立,通常可以并行;涉及架构变更的任务则需要更严格的协调。
锁也可以采用乐观或悲观策略。悲观策略是在任务开始前先声明资源占用,避免冲突;乐观策略则允许任务先执行,在合并时检查冲突并处理。无论采用哪种方式,关键都是让任务的修改范围可见,避免多个 Agent 在同一处重复工作、互相覆盖或者产生不一致的实现。
任务分解还涉及搜索策略。模型在强化学习中可能倾向于沿着一个看起来合理的方案持续深入,采用深度优先的方式把一个想法实现并优化。但真实设计空间往往有多个分支,早期的不同方案可能对最终结果产生很大影响。如果一开始就选错方向,后面再投入大量资源优化也可能没有意义。因此,我需要在广度和深度之间平衡:先探索若干候选方案,再对更有希望的方向进行深入实现。
多 Agent 的价值不只是同时写更多代码,也包括利用不同模型的判断差异进行交叉审查。例如,让 GPT 和 Claude 分别检查同一个方案,互相挑出问题,可以减少单一模型的盲点。不同模型可能具有不同的推理习惯和错误模式,因此多样性本身可以成为质量保障的一部分。但并行数量不是越多越好;如果大量 Agent 同时修改同一核心模块,协调成本会迅速上升。
Agent Loop 与版本管理
Agent-native 开发需要一个持续运行的工作循环。可以把工作区状态视为系统状态,每一步选择一个任务或 action,让 Agent 对仓库执行一次可观察的修改。Git 仍然是重要基础,因为最终交付物仍然是一个代码仓库,需要提交、分支、合并和发布。Agent 的任务不应只停留在对话记录里,而应当与具体的代码状态和提交历史关联起来。
我可以为 Agent 建立任务日志或 logbook,记录每个任务的描述、负责人、状态和结果。任务可以处于待处理、进行中、已完成、被拒绝或归档等状态。再把任务和架构图关联起来,就能看到每个模块当前有哪些 Agent 在工作、任务完成到什么程度、是否存在阻塞。项目负责人不必逐行阅读所有 Agent 的输出,而可以先从架构和任务状态判断整体进展,再进入具体问题。
CI/CD 与自动化门禁
Agent 生成代码的速度很快,因此需要把工程约束转化为自动检查。CI/CD 不只是上线工具,也是开发过程中的反馈系统。提交前可以执行格式检查、静态分析、单元测试和敏感信息扫描;推送前可以检查分支状态;合并前可以运行更完整的测试和评审。不同阶段可以设置不同强度的门禁:快速检查尽量在本地完成,全量验证则在主分支或发布阶段执行。
例如,项目可以规定 API Key 和密钥不能进入仓库,文档长度不能超过约定范围,代码必须通过 lint 和测试。Agent 可以在本地运行 pre-commit hook,发现失败后再根据错误信息修复。如果文档过长,Agent 可以回到项目说明文件中寻找规则并调整内容。这样的自动化约束,能让 Agent 在每次修改时都收到明确反馈,而不是等到最终交付时才发现问题。
随着项目规模扩大,Agent 的上下文会越来越长,注意力也可能分散。即使项目说明中已经写明了规范,Agent 也未必能在庞大的上下文中始终遵守。因此,重要约束不应该只写在自然语言文档里,还应该尽可能转化为自动检查。人类写文档的速度较慢,AI 生成内容的速度却很快,文档膨胀、重复说明和不一致会成为新的维护问题。
人在 Agent-native 开发中的职责
我不应该把“让 Agent 自己做”误解为“我不再负责”。我的主要职责从逐行编码转向设定环境、任务边界、架构约束、反馈机制和验收标准。我需要判断当前任务是否已经足够清晰,是否能被拆分,哪些修改可以并行,哪些需要串行完成,以及最终结果是否满足用户意图。
Agent 可以承担员工甚至团队的执行工作,但系统负责人仍然需要管理整体结构。一个可行的工作方式是:我先明确意图和核心规格,再把需求拆成有边界的任务;Agent 在独立工作区中实现;自动化门禁负责发现可机械检查的问题;不同 Agent 或人工评审负责审查设计;最后由我确认整体行为是否符合预期。这样,AI 才真正进入软件工程流程,而不是只负责生成一段代码。
DeepSeek Harness:以插件生态组织 Agent 能力
为什么需要 Harness
当 Agent 从单个对话工具变成多个协作执行者时,传统的代码编辑器和版本控制工具可能不再足够。一个人独立写代码时,工作流比较简单;当一个人同时管理多个 Agent、多个子任务和多个工具时,就需要一个能够协调模型、工具、会话、状态和扩展能力的运行环境。Harness 可以理解为 Agent 的运行支架:它不只是模型调用接口,还负责组织任务执行、工具协作、上下文、事件和状态。
DeepSeek Harness 值得研究的地方,在于它把插件机制放在架构中心。其设计思路与操作系统有相似之处:内核不需要知道每个插件具体做什么,只需要提供一套稳定机制,让不同插件能够加载、通信和组合。可以把插件想象成独立进程或独立模块,每个插件拥有自己的私有状态;插件之间不应该随意访问对方内部数据,而是通过消息和接口协作。
Everything is a Plugin
“Everything is a plugin”意味着系统能力尽量以插件形式存在,而不是把所有功能硬编码进一个庞大的核心模块。插件可以提供服务、注册工具、监听事件,也可以依赖其他插件。加载插件时,需要加载它的依赖;卸载插件时,也要妥善处理依赖和资源回收。这与操作系统创建进程时分配资源、进程结束后回收资源的思想相似。
如果每个插件都能随意发送任意消息,系统就会失去约束;如果插件之间完全不能通信,插件生态也没有意义。因此,真正重要的是协作机制。Harness 需要提供共享的运行环境、明确的消息格式、服务定义、权限管理和事件扩展点,让插件既能保持独立,又能在需要时共享信息。
Event Bus 与 Session
Event Bus 是插件协作的关键机制。系统中的插件可以向事件总线发布事件,也可以订阅自己关心的事件。事件需要有明确的类型和结构,发布者与订阅者必须遵守约定。TypeScript 等类型系统可以在编译阶段检查消息格式,减少插件之间因为数据结构不一致而产生的错误。插件也可以通过 hook 监听某些事件,在事件进入后执行自己的逻辑,必要时对事件进行处理或修改。
Harness 还需要明确 Agent 的核心状态。对于以大语言模型推理为中心的系统,Session 是一个重要抽象。Session 的事件日志可以作为会话历史的事实来源,模型看到的消息历史则可以从事件记录中派生出来。这是一种事件溯源思想:系统保留发生过的事件,再通过 projection 得到当前会话状态。只要历史事件足够完整,就可以回放会话、检查模型执行过程,也可以让不同插件基于同一份事实构建自己的视图。
这种设计能够为开发者提供很有价值的调试信息。例如,Trajectory 可以记录 Agent 的执行轨迹,让开发者观察模型何时调用工具、收到什么结果、如何继续推理。对 Agent 系统来说,了解模型的执行历史与最终结果同样重要,因为错误可能发生在工具调用、上下文构造、事件处理或状态投影的任意环节。
上下文注入与动态界面
插件有时需要让模型遵守额外的输出协议。例如,一个动态 UI 插件可能要求模型生成带特定标记的 HTML 片段,插件再根据标记把输出投影成界面组件。为了让模型知道这个协议,插件可以在构建上下文时,通过 hook 向 system prompt 注入一段简短说明。模型输出后,插件检查消息内容,识别约定标记,再更新自己的 UI 状态。
这相当于定义了一种领域特定语言(DSL):模型按照协议输出结构化内容,插件负责解释和呈现。重要的是,这种扩展不一定需要修改 Harness 的核心实现。插件只要使用系统提供的事件、上下文和投影接口,就可以增加新的交互能力。
如果 Harness 原生提供 Web UI,但我更喜欢命令行,也可以通过 Event Bus 构建 TUI(Text User Interface)。只要能够监听 Session 相关事件,例如新的消息、模型开始生成、token 持续输出和工具调用结果,就可以把这些事件投影到终端界面中。这样,Web UI 不必为了支持命令行而被重写,新的界面只需要订阅相同的会话状态。
让 Super App 成为 Agent 的宿主
Harness 的插件生态还可以扩展到传统应用。以 WPS 或 Excel 为例,应用内部有文档、幻灯片、表格和各种可编辑对象。要让 Agent 参与编辑,不一定需要把整个应用推倒重做,只需要提供一层很薄的适配接口:选中对象后可以锁定,随后把对象交给 Agent 上下文;Agent 通过工具调用提出修改;应用再把修改后的对象取回并替换原对象;一次会话结束时,将结果作为提交保存。
这样,画布可以对应 Session,对象编辑请求可以对应 Tool Call,模型完成一轮修改后的提交可以对应 Commit。Agent 不直接随意修改整个应用的内部状态,而是通过明确的对象交接协议完成工作。只要传统应用提供少量必要接口,就能接入 Harness 的插件生态。
数据库插件也可以为 Super App 提供个人数据。例如,填写一份表格时,应用可能需要用户过去几年发表的论文、管理的学生或其他个人资料。如果这些信息已经存在于个人数据库中,Agent 就可以通过插件查询必要数据,再把结果填入表格,而不必反复截图、识别界面和使用 Computer Use 点击每个输入框。个人电脑、数据库、记忆和工具都可以通过统一总线协作。
这也引出了 Agent OS 的设想:在应用和 Agent 之间建立一个更底层的能力层,让不同 Super App 能够共享工具、数据和自动化能力。传统应用主要面向人提供界面,Agent-native 应用则需要向 Agent 暴露清晰的能力接口。未来的应用生态可能不再以一个个孤立 App 为中心,而是以可组合的服务、插件和 Agent 工作流为中心。
软件的演化:从一艘小船到一艘航空母舰
复杂系统不是一次性造出来的
航空母舰是一个极其复杂的工程系统。如果第一次走上航母甲板,很容易产生疑问:如此复杂的系统怎么可能由人类设计出来?但航母并不是在某一天突然出现的。它经历了从普通船只到能够搭载飞机的船只,再到现代航空母舰的长期演化。最初的系统可能只需要完成在水面航行的任务,之后随着需求变化,逐步增加甲板、飞机起降能力、动力系统、武器系统、通信和各种保障设施。
我用一艘最简单的独木舟作为初始状态。它只有一个核心能力:在水面漂浮和航行。之后每一次改进,都可以看作一次提交(Commit):增加一个功能、修复一个问题、调整一个结构,或者引入一项新的技术。大部分变化可能只是小改动,但少数变化会改变整个系统的架构。例如,把一艘普通船改造成能够起降飞机的船,就不是简单增加一个按钮,而是引入新的甲板布局、起降流程和一系列配套机制。
即使是很细小的设计,也可能影响整个系统的可靠性。管线应该放在左侧还是右侧,热蒸汽管路是否做好隔热,设备之间是否留有足够空间,都可能影响运行安全。系统演化既包括重大的架构变更,也包括子系统重构、局部优化和 Bug Fix。真正复杂的系统,是许多代工程师在长期反馈中不断调整的结果。
用 Git 历史理解复杂系统
软件仓库把系统演化过程记录下来。今天面对几十万行代码的项目,如果直接从当前版本开始阅读,很容易迷失在复杂性中。更有效的方法是找到某个功能最初被引入的提交,从当时较简单的系统状态开始理解,再沿着提交历史向前追踪。
我可以把某个 Feature 的提交拿出来,尝试把它 rebase 到项目更早的状态中,观察它在不同阶段是否仍然合理。比如,在一艘只能漂浮的小船上增加飞机起降功能显然不合理;但当船体足够大、甲板结构和动力系统逐渐成熟后,这个需求才变得可行。通过这种方式,我能理解一个功能依赖哪些前置能力,以及它为什么必须在某个阶段之后才能出现。
软件架构良好的一个表现,是新增功能通常不会与系统所有部分都发生强耦合。很多提交与某个特定 Feature 并没有直接关系,只有少数关键提交会影响它。理解这些关键依赖,比一次性阅读所有代码更有效。对于大型项目,我应该先找到一个自己能够理解的历史版本,再逐步把目标功能引入其中,观察它与其他功能发生了哪些冲突、冲突如何解决。
DeepSeek Harness 的提交历史
DeepSeek Harness 的开发历史也可以用这种方式理解。它并不是从一个完整的复杂 Agent 系统开始的,而是先有一个初始状态和一个最小可行的内核。相关的 Cordis 插件框架本身也有更早的历史:它最初来自管理 QQ Bot 插件的需求,开发者发现插件加载和卸载越来越麻烦,于是逐渐抽象出一个能够管理插件及其依赖的框架。
在后续开发中,DeepSeek Harness 将插件框架整合进来,再逐步实现模型推理、Agent Loop、会话、事件总线和更多能力。早期提交中有些是非常基础的架构决定,后面的功能则建立在这些基础上。通过阅读最初的一批提交,我可以看到一个复杂系统如何从 MVP 开始,一点一点形成今天的结构。
这也是开源项目的重要价值。源码和 Git 历史不仅告诉我“现在的代码是什么”,还告诉我“它为什么变成现在这样”。如果我只看当前状态,就会面对大量看似无法理解的复杂性;如果我从历史演化入手,就可以追踪每个 Feature 的来源、依赖和设计变化。
从小任务理解 Agent 的能力边界
一个软件仓库中的提交,大多对应一个相对小的任务,例如修复 Bug、增加一个小功能或调整一个模块。由此可以提出一个问题:Agent 能否完成这些小任务?SWE-bench 等基准正是围绕真实软件仓库中的问题修复任务,评估模型能否理解代码、定位问题并提交修改。
如果一个 Agent 能够稳定完成大量小任务,它就可以参与软件演化。但这并不意味着它能独立设计整个大型系统。小任务通常有较明确的上下文和验收条件;架构级任务则需要理解长期依赖、历史决策和系统整体目标。模型可以通过阅读提交历史、分析设计文档和比较不同版本来逐步理解项目,但任务的规模和不确定性越大,就越需要更长的推理、更充分的探索和更严格的验证。
我也认为,亲自从零实现一些小系统仍然有价值。通过自己构建操作系统、编译器、数据库或其他课程项目,我能理解系统最初的状态和关键机制。以后再阅读大型项目时,我就可以把当前复杂结构与自己理解过的简单模型联系起来。如果把所有学习项目都交给 AI 代写,我可能得到代码,却失去理解系统如何演化的经验。
理论计算与 AI 能力的背景
软件演化这一讲还讨论了理论计算领域的进展。理解复杂系统时,不能只看工程实践,也要理解计算复杂性中的基本概念。复杂性理论通常用多项式时间刻画一类可有效计算的问题。选择多项式时间有一个重要原因:它在函数组合下具有良好的封闭性。一个多项式时间算法调用另一个多项式时间算法,组合后的计算仍然属于多项式时间。这种性质使得我们能够把已有算法当作模块自由组合,而不必每次重新分析整个计算过程。
课堂中还提到指数时间假设(Exponential Time Hypothesis,ETH)以及它与 、 问题的关系。相关研究如果能够把某些问题的复杂性下界向下推进,即使没有直接得到多项式时间算法,也可能改变研究者对问题难度的认识。这里的重点不是把某个结果误解为 ,而是看到理论计算中的边界也可能随着新算法而改变。数学结构之所以有吸引力,正是因为少量基本概念能够推出大量结论;但这种简洁性也可能是人类为了控制认知复杂性而建立的一种抽象方式。
软件质量保障:从测试到可信的系统行为
为什么 Agent 时代更需要质量保障
AI Agent 能够生成大量代码,但人类仍然需要对软件质量作出承诺。代码生成速度越快,未经验证的实现也可能越多。质量保障不是在项目最后阶段随手运行一次程序,而是贯穿需求、设计、实现、测试、调试和维护的全过程。
我把软件理解为物理世界过程在信息世界中的投影。一个 Bug,就是这种投影与规格之间出现了偏差。程序员和模型都可能产生错误,因此不能因为代码看起来合理、能够编译或者通过一个样例,就认为它是正确的。未测试的代码不能被默认可信,测试和断言是建立信心的基本手段。
Fault、Error 与 Failure
软件缺陷的传播可以分成三个层次:Fault、Error 和 Failure。Fault 是程序中的缺陷,例如手滑写错一行代码、算法设计错误、内存管理错误或边界条件遗漏。Error 是程序运行时进入了不符合规格的内部状态。Failure 则是外部可观察到的错误行为,例如程序崩溃、输出错误结果、运行时间远超预期或服务无法继续提供功能。
这三个层次并不会自动发生。程序中存在 Fault,不代表任意输入都会触发它;只有合适的输入和执行路径,才可能让程序进入 Error 状态。即使进入 Error,也不代表外部一定能观察到 Failure。例如,程序可能覆盖了一个当前没有被使用的内存地址,内部状态已经违反规格,但最终输出仍然正确。这样的错误可能长期隐藏,直到某次执行使用了被破坏的数据才暴露出来。
因此,测试需要解决两个问题:一是尽可能构造输入,让潜在 Fault 暴露为 Error;二是为程序状态和输出建立足够强的检查,让 Error 尽可能表现为可观察的 Failure。Specification 和 Assertions 在这里非常重要。规格定义程序应该满足什么性质,断言则在运行过程中检查这些性质是否仍然成立。
真实系统中的错误案例
课堂中提到过一个火箭软件的案例:程序中存在浮点数转换为 16 位整数时缺少越界保护的问题。这个缺陷在普通测试中可能没有触发,但程序运行足够长时间后,计数器发生溢出,进而产生异常。系统虽然具备异常处理和恢复流程,却仍然可能因为错误状态影响后续控制,最终造成任务失败。
这个案例说明,测试不仅要覆盖常见输入,还要考虑长时间运行、数值边界、计数器溢出、异常恢复和状态传播。一个程序在短时间内运行正常,不代表它在真实任务持续运行时也正确。尤其在航天、医疗、金融和基础设施系统中,故障可能经过很长时间才暴露,质量保障必须覆盖整个运行周期。
测试输入与测试预言机
测试不只是生成输入,还需要判断输出是否正确。对于一个算法题,我可以随机生成很多整数序列,让程序运行并得到结果,但如果没有已知答案或可验证性质,我仍然不知道输出是否正确。这个问题就是测试预言机(Test Oracle)问题:我需要一种机制判断程序的结果是否符合规格。
有些程序很容易检查,例如结果应该满足某个范围、排序结果应该保持元素集合不变并且有序;有些程序则难以直接判断,例如一个复杂动态规划程序输出了一个数值,单凭这个数字很难知道它是否正确。因此,测试设计需要同时考虑输入覆盖和结果检查。对于复杂系统,我可以通过独立实现、性质断言、参考模型、状态不变量或人工审查来增强测试预言机。
黑盒测试与白盒测试
黑盒测试关注外部可观察行为,不需要知道内部实现细节。在线评测就是典型例子:输入一组数据,检查程序输出是否正确、是否超时、是否崩溃。黑盒测试可以验证系统是否符合外部接口和行为规格,但不一定能指出内部哪一行代码出了问题。
白盒测试则利用程序内部结构设计测试,关注语句、分支、路径和状态变化。测试可以统计语句覆盖率、分支覆盖率和路径覆盖情况。一个 if 语句有两个分支,就应该尽量让测试覆盖两个分支;循环一次和循环两次也可能触发不同逻辑,因此不能只依赖一个普通输入。覆盖率不能直接证明程序正确,但它能告诉我哪些代码路径尚未被测试触达。
测试输入还应关注边界值,例如数组长度为零、一、最大允许值,数值接近上下界,或者状态转换处于临界条件。决策表和状态转换表可以帮助我整理多条件组合,避免只测试最常见的路径。对于大型项目,测试用例需要系统化组织,而不是依赖开发者临时想到什么就测什么。
单元测试、集成测试与系统测试
不同层级的测试成本不同。单元测试针对较小的函数或模块,执行速度快、定位问题容易,因此适合大量运行。集成测试检查多个模块之间的接口和协作。系统测试则从更完整的系统视角验证端到端行为,成本通常更高,也更容易受到环境和外部依赖影响。
如果一个单元测试就能发现的问题,却直到系统测试阶段才被发现,就浪费了更多时间和资源。因此,测试策略应该尽量在低成本层级发现问题,再用更高层级的测试验证模块组合和整体行为。自动化测试还可以统计覆盖率,对没有覆盖的代码发出警告,并不断补充测试用例。
QuickCheck 一类性质测试工具可以根据开发者描述的性质自动生成输入,尝试寻找反例。它改变了传统测试只依赖人工编写固定样例的方式:我不必预先知道每个错误输入是什么,而是先明确程序必须满足的性质,再让工具探索输入空间。性质测试并不能自动保证规格正确,但能显著扩大测试范围。
用 CSGO 理解可测试架构
假设我要为一个类似 CSGO 的游戏系统编写测试。游戏状态中包含角色、子弹、坐标、速度、武器类型、碰撞关系和玩家指令。游戏每个 Tick 都会根据当前状态和输入更新下一帧状态。只要模拟规则确定,同一个初始状态和同一组指令,就应该产生相同的后续状态。
因此,我应该把游戏引擎和图形渲染分开。引擎负责状态更新、碰撞判定、射击逻辑和角色行为;渲染层只负责把状态呈现给玩家。测试可以直接构造游戏状态,输入一组动作,检查下一帧状态是否符合预期,而不必每次都启动完整图形界面。状态模拟越确定、模块边界越清晰,测试就越容易自动化。
架构决定可测试性
质量保障最终取决于架构。一个函数如果依赖大量全局变量,就需要考虑所有可能的全局状态、并发修改和执行顺序。测试时,我必须构造复杂环境,才能验证这个函数是否正确。相反,纯函数只依赖明确输入,不产生副作用;相同输入总是得到相同输出,正确性责任也更集中,因此更容易进行单元测试和形式化推理。
函数式设计并不是万能的,但它有助于减少隐式状态和不必要的耦合。Rust 的所有权和生命周期机制会迫使开发者重新思考状态由谁持有、何时转移以及何时释放。把对象显式交给另一个模块,再由对方返回结果,通常比共享大量全局可变状态更容易理解和测试。引用计数等机制也可以帮助管理对象生命周期。
高阶函数会带来新的设计问题:函数可以接收函数作为参数,也可以返回函数或 Lambda。此时,函数的责任范围、调用者和被调用者之间的契约需要更加清晰。函数式设计不是让所有问题自动消失,而是通过明确输入、输出和副作用,降低测试时需要考虑的状态空间。
如果架构本身已经严重耦合,单纯增加测试用例往往只能缓解症状。重构才是改善代码质量的重要途径。把全局状态拆分为显式输入,把业务逻辑从界面和外部 I/O 中分离出来,把复杂模块切分成清晰接口,通常能够从根本上降低测试成本。
物理设备也需要闭环测试
当软件与物理世界交互时,测试不能只停留在模拟环境。课堂中提到过通过舵机控制 SD 卡插拔的实验:如果 Linux 驱动不稳定,就需要构造真实的插拔过程,观察设备是否能够正常工作。为了实现自动化,可以使用 3D 打印部件或其他机械结构,让软件控制舵机完成插拔,再读取设备状态。
这种测试说明,物理接口也需要被抽象和验证。模拟器可以帮助我快速检查逻辑,但真实设备的驱动、时序、机械结构和外部环境仍然可能带来问题。AI 可以帮助生成控制代码和测试流程,但前提是我理解设备接口、测试目标和验收标准。
调试理论:从测试失败定位到真正的缺陷
测试失败意味着什么
测试失败能够告诉我:当前程序的某次执行没有满足预期。但它不一定直接告诉我 Fault 在哪里。错误信息、异常类型和调用栈可以提供线索。例如,空指针异常往往意味着某个对象在使用时并不存在;如果错误发生在某个函数附近,我就可以优先检查该函数的输入、状态和调用关系。
测试失败还会改变我对缺陷位置的判断。某个测试覆盖了哪些模块、在哪个状态失败、出现了什么异常,这些信息可以帮助我排除不相关区域。调试不是盲目地修改代码,而是根据证据不断缩小可能原因的范围。
沿着执行轨迹寻找第一个错误状态
程序运行可以看作一系列状态变化。一个 Fault 被触发后,程序可能从某个时刻开始进入 Error 状态,之后的计算都带着错误继续执行。最终看到的 Failure 可能发生在很久之后。要定位根因,我应该寻找程序从正确状态第一次进入错误状态的位置,而不是只修改最后崩溃的那一行。
如果我能够观察或记录执行轨迹,就可以沿着状态序列进行二分查找。先检查中间某个时刻的状态是否正确:如果正确,说明错误发生在更后面;如果已经错误,说明错误发生在更前面。反复缩小范围,就能找到第一个引入错误状态的操作。这种方法要求错误状态具有一定的持续性,且我能够判断某个时刻的状态是否符合规格。
日志、断点、调用栈、状态快照和测试记录都可以帮助建立执行轨迹。对于 Agent 系统,也应该记录模型调用、工具返回、上下文变化和事件投影,因为最终结果错误时,问题可能来自模型推理,也可能来自工具、插件或状态管理。
调试是一种基于证据的推理过程
我可以把调试理解为不断提出假设并验证假设的过程。先根据测试失败和错误信息提出可能原因,再设计一个能够区分不同假设的实验。实验结果会排除一部分可能性,帮助我进一步缩小范围。每次修改都应该有明确理由,并通过回归测试确认问题是否真正解决。
如果只是不断修改代码,直到某个样例通过,我可能只是掩盖了问题,甚至引入新的缺陷。更可靠的做法是先复现问题,定位错误状态,理解其传播路径,再修复根因,并增加一个能够稳定复现原问题的测试用例。这样,未来修改代码时,测试就能提醒我是否再次引入同样的缺陷。
断言、契约与形式化验证
断言(Assertion)用于表达程序运行时必须满足的性质。例如,函数收到输入时要求某个条件成立,执行结束后要求某个结果成立。面向契约的设计把这些要求组织为前置条件(Precondition)和后置条件(Postcondition)。前置条件描述调用者必须提供什么,后置条件描述函数完成后能够保证什么。
霍尔逻辑常用三元组表达这种关系:前置条件、程序语句和后置条件之间存在一个正确性关系。对于一个账户取款函数,前置条件可能要求账户有效、金额为正;后置条件则要求余额按规则变化,并且不会出现不允许的状态。通过明确这些契约,我可以在设计阶段发现原本容易被忽略的边界情况,而不是等到实现完成后才处理。
如果函数的前置条件和后置条件能够被证明,程序正确性就不再只依赖测试样例。更进一步,如果系统中每个模块的契约能够正确组合,就有机会从局部性质推导出整体系统满足某些规格。这也是形式化验证工具和证明辅助工具希望实现的目标。
自然语言、形式语言与 UML 的边界
形式化方法不能绕过意图与规格之间的差距。自然语言直接连接人的认知,不同人对同一句话可能产生不同理解;数学语言通过公理、定义和推导建立更确定的语义,因此更容易在不同人之间对齐。UML 试图在自然语言需求和编程语言实现之间建立一种中间层,让系统中的对象、关系、状态和交互能够被结构化描述。
UML 的目标不是把所有人的想法都变成完全确定的数学对象,而是把能够明确的部分表达出来,并把仍然需要协商的部分保留下来。它的规范非常庞大,核心问题却可以概括为:哪些意图必须被固定成明确语义,哪些内容可以保留弹性?如果所有内容都不加区分地写成自然语言,团队很难确认彼此是否理解一致;如果过早把所有内容形式化,又可能把尚未想清楚的需求错误地固定下来。
形式化证明还必须警惕定义错误。即使证明系统内部的推理完全正确,如果最初形式化的问题与真实意图不一致,证明就没有解决原问题。有人声称证明了某个著名数学猜想,后来却发现形式化定义把问题简化成了一个近乎恒真的命题。这类例子提醒我:验证推理正确性与验证问题定义正确性必须分开处理。
从需求到交付:一套可持续迭代的软件工程方法
建立从意图到规格的工作流程
一个软件项目开始时,我首先要理解人的意图,而不是立即让 Agent 写代码。我需要确认目标用户、使用场景、业务规则、约束条件和验收标准,并主动寻找例外情况。需求不一定一次就能完全明确,但应该把当前已经确定的内容和仍待确认的问题区分开。
随后,我需要把需求转化为规格。规格应该尽量明确输入、输出、状态变化、权限、异常行为和非功能要求。对于复杂系统,还需要建立需求追踪关系,确保每个重要需求都能对应到设计、实现和测试。规格并不是越长越好,关键是它是否准确、可检查,并且能够支持后续设计。
用架构管理复杂性
在架构阶段,我需要识别本质复杂性,并通过模块、接口、数据模型和抽象层次将其组织起来。重要决策应该记录理由和影响范围,因为今天的设计会限制未来的演化。数据库、事件溯源、MVC、插件机制和服务接口都只是工具,选择它们之前必须先理解问题的结构。
对于不确定性较高的设计,我应该优先构建 MVP 或 pilot program,尽早验证关键假设。原型的目标不是一次性实现所有功能,而是确认最重要的依赖路径能否成立。随后通过敏捷迭代逐步扩展,并用测试驱动开发把反馈提前。
让 Agent 在明确边界内执行
当我把任务交给 Agent 时,需要给它足够清晰的上下文、任务范围、可修改文件、接口契约和验收标准。多个 Agent 可以并行处理相互独立的任务,但共享模块必须有协调机制。Git、工作区隔离、任务日志、架构图和事件记录可以帮助我理解每个 Agent 正在做什么,以及它的修改会影响哪些部分。
自动化门禁应尽可能覆盖可机械检查的规则,包括格式、静态分析、单元测试、敏感信息扫描、文档规范和合并条件。模型负责执行任务,自动化系统负责及时反馈,人负责判断整体设计和最终行为是否正确。对于高风险任务,还应该安排独立评审和更严格的系统测试。
通过测试、调试和重构持续改进
测试应该从低成本层级开始,逐步扩展到集成和系统层级。每次发现缺陷,都应该尝试构造稳定的复现用例,定位第一个错误状态,修复根因,并把测试加入回归套件。测试覆盖率可以帮助发现没有被触达的代码,但不能替代对规格和测试预言机的思考。
如果测试越来越难写,通常说明架构中存在隐式状态、过多耦合或边界不清的问题。此时应该考虑重构,而不是无限增加测试补丁。好的架构让系统更容易理解、测试、扩展和维护;坏的架构则会让每一次修改都变成高风险操作。
结语:软件工程的核心是管理复杂性与不确定性
从软件工程诞生之初到 Agent-native 开发,技术工具已经发生了巨大变化,但核心问题仍然存在。人的意图需要被理解,需求需要被明确,架构需要管理复杂性,实现需要接受验证,软件还必须在不断变化的环境中持续维护。瀑布模型、MVP、敏捷开发、TDD、需求追踪、事件溯源、插件架构、测试和形式化验证,都是人类为解决这些问题而发展出的不同方法。
我不把软件工程理解为一套固定的流程模板,而把它看作一组帮助我控制风险的原则:尽早发现错误,明确模块边界,记录关键决策,保持依赖可追踪,让系统能够被测试,并让每次修改都能得到反馈。AI 降低了实现成本,却没有自动消除意图和规格之间的差距,也没有自动保证架构和质量。真正的 Agent-native 开发,不是让模型替我写更多代码,而是让我能够借助模型,把一个复杂的软件工程过程组织得更清楚、更可靠,也更容易持续演化。
我虽然行过死荫的幽谷,也不怕遭害,因为你与我同在。
诗篇 23:4