AI 与上下文

Ontology-Driven Design:如果本体成为 AI 生成代码的安全网?

当 AI 代理编写代码时,测试能通过,业务却可能悄悄漂移:同一个概念出现两个名字,某条规则被违背,一个已被弃用的观念死灰复燃。从代码中提取本体,在每次开发前先与意图比对,再与产出的代码比对,就能让这些漂移显形,并把有意的演进与错误区分开来。

Info

原文为法语。由 AI 翻译——保留的是含义,而非文风。

《Le contexte》一书封面
《Le contexte》一书的延伸

本文延伸了我在《Le contexte》一书中写下的内容。下载阅读,或在 Amazon 上购买。

TDD 用测试来引导开发。如果我们也用本体来守住软件的业务一致性呢?这是我正在用 Claude Code 探索的思路:从代码出发构建本体,再逐步反转这个过程,让本体来引导、检查并陪伴软件的演进。

代码能跑。但它做的还是对的业务吗?

有了 Claude Code 这样的 AI 代理,我们进入了一个写代码越来越容易的时代。

我描述一个功能。代理探索现有代码,修改好几个类,添加函数,调整接口,编写测试。几分钟后,它把成果交到我面前。

代码能编译。测试通过。

但一个问题依然存在:这段新代码还遵守我的应用的业务逻辑吗?

代理可以写出技术上正确的实现,同时在业务模型中引入不一致。它可能用两个名字指同一个概念,重新引入一个已被弃用的观念,或者创建一条与现有规则相矛盾的规则。

当应用不断壮大,而且越来越多的修改由 AI 代理完成时,这个问题就变得格外有意思。

怎样给它们一个共同的业务基准?怎样检测漂移?又怎样避免这个基准变成又一份文档,最终与软件脱节?

正是从这些问题出发,我开始在自己的个人开发中用 Claude Code 试验一种做法,我在这里称之为 Ontology-Driven Design(ODD)。

为了说明这个做法,我会以一个虚构的 ERP 为例。

第一步:从代码中提取本体

我的出发点相当简单。

我把源代码视为实际实现行为的事实依据。规格说明描述的是一种意图;代码揭示的是应用真正做了什么。

于是我请 Claude Code 去探索我的应用代码,并把其中的业务领域表示提取到一个 Markdown 文件里:ontology.md。

这个文件主要描述:

  • 业务概念:客户、订单、报价单、发票、红字发票……;
  • 它们的属性和关系;
  • 业务规则和不变量;
  • 状态及其转换;
  • 用来指称这些概念的词汇。

在我们虚构的 ERP 中,一张客户订单关联一个客户。它有一行或多行明细。它可以来自一张报价单。它可以被确认、取消或开票。

这些信息在代码中不一定写在同一个地方。有些规则是显式的,有些则分散在多个函数里。

Claude Code 可以去查找它们,并尝试还原。

结果不是一份完美的规格说明。它是对业务的一种结构化解读,来自业务的实现本身,也就带着相应的局限:隐含的规则可能被漏掉,历史遗留的行为也可能被误当成有意设计的规则。

但我得到了一样有价值的东西:一份独立于实现技术细节的领域表示。

ontology.md 这个文件成了理解软件的参照点。

第二步:对照本体检查新代码

有了这份本体之后,我请 Claude Code 在开发新功能时使用它。

想法是把所做的修改与 ontology.md 中的概念和规则作比较。

比如,假设本体写明已确认的发票不能再修改。

如果 Claude Code 添加了一个功能,允许在确认后更改发票明细,它就必须指出这一矛盾。

同样,如果本体明确区分了报价单和订单,代理就不应该在没有明确理由的情况下,引入一个混淆这两个概念职责的函数。

这是第一张安全网。

但它有个缺陷。

检查发生在代码产出之后。

代理已经完成了它的工作。它可能已经创建了好几个类,添加了方法,还围绕对业务的错误理解写了测试。

我们能发现问题,但随后还得回头去改已经产出的代码。

换句话说,我加了一道事后检查。有用,但不够。

第三步:从 Test-Driven Development 中获得启发

就在这时,我想到了 TDD。

Test-Driven Development 的原则众所周知:在实现某个行为之前,先写一个表达预期的测试。测试失败,我们编写让它通过所需的代码,然后在保留这张安全网的前提下改进实现。

为什么不对本体采用类似的逻辑呢?

于是我请 Claude Code 改变它的流程。

写代码之前,它必须先把所要求的功能与现有本体比对。

操作的顺序变了。

来看一个新需求:

“我希望允许创建客户订单时不必经过报价单。”

如果本体写明订单必须来自报价单,代理在修改代码之前就会发现矛盾。

但这个矛盾不一定是需求本身的错误。

它可能对应着业务一次完全正当的演进。

因此代理必须认识到:开发者的意图改变了一条现有规则,需要提出这条规则的演进方案,并判断它对相关概念的影响。

随后它才能基于修订后的业务模型来开发这个功能。

流程于是变成:

  1. 理解所要求的功能。
  2. 找出相关的本体概念和规则。
  3. 指出需求与现有模型之间可能存在的矛盾。
  4. 解决这些矛盾,区分有意的演进和设计错误。
  5. 开发功能。
  6. 检查产出的代码与预期的业务模型是否一致。

这并不是严格意义上的 TDD:本体不是一组自动化测试,LLM 的分析也无法提供与确定性断言相同的保证。

但理念很接近:在实现之前先定义预期和约束,而不是事后才发现不一致。

到了这一步,本体开始在开发中扮演主动的角色。

这又带出了一个新问题。

第四步:本体必须随代码一起演进

如果本体成为开发的基准,该如何让它保持最新?

我绝不想创造一份新文档,让人每次应用演进时都得记着手工去改。

那等于回到最初的问题:文档与代码脱节。

于是下一个想法,是在流程中引入机械式的部分。

一个脚本分析源代码的变化,尤其是基于 Git,识别出新增、修改或删除的元素:

  • 函数和方法;
  • 类和接口;
  • 模块和包;
  • API 的签名和契约;
  • 通过 MCP 暴露的工具、资源和契约;
  • 修改中可识别的业务关系和行为。

目标不是根据应用的技术细节来重建本体。

恰恰相反,我希望保持独立于实现选择。六边形架构、Domain-Driven Design,或者任何其他的代码组织方式(哪怕非常糟糕),都不应该把它们的结构强加给本体。

本体表示的是业务领域,而不是技术架构。

一个类不一定是业务概念。一个新的包可能只是技术上的重组。一个函数可以实现某条业务规则,而本身并不构成一个新概念。

因此需要把两项操作分开。

第一项是机械式的:精确确定发生了什么变化。

第二项是语义层面的:理解这些变化是引入、修改还是违背了业务概念。

LLM 就在这里登场。

脚本生成一份修改清单。LLM 把这份清单与当前的本体,以及触发开发的指令进行比对。

接下来可能出现几种情形。

出现了新的业务概念。 代理可以提议或准备把它加入本体,连同它的关系和相关规则。

现有概念的含义发生了变化。 需要判断这是有意的演进还是漂移。

两个概念变得不一致。 代理指出这一矛盾,并附上相关代码的引用。

词汇出现分歧。 两个名字指同一个业务实体,或者一个现有名字被用来指另一个观念。

变更纯属技术性。 无需对本体做任何修改。

有一点始终关键:代码不该自动被当作正确的一方。

如果某个代理引入了错误,我不希望第二个代理去修改本体,好让这个错误变得可以接受。

三角:意图、代码与本体

我认为,这才是这个概念真正的演进之处。

只比较代码和本体是不够的。

需要比对三个要素:

意图:开发者向 Claude Code 提出的要求。

代码:实际实现的内容。

本体:作为基准的业务概念和规则。

正是对这三者的比较,才让我们看清一处偏差的性质。

回到我们虚构的 ERP。

本体写明,客户订单必须来自报价单。

开发者明确要求让报价单变成可选。

Claude Code 修改了相关函数,引入了直接创建订单的可能。

本体与新代码现在彼此矛盾。但代码符合意图。

因此正确的结果不是一概拒绝这次修改,而是提出本体相应的演进方案,然后去查找软件中其他仍假定报价单为必需的地方。

相反,如果 Claude Code 在没有任何指令要求的情况下取消了这项必需条件,这处偏差就值得怀疑。

这个区别至关重要。

不一致并不总是 bug。它可能意味着业务发生了有意的转变。

系统的作用不是阻止变化,而是让变化显性、一致且可追溯。

迈向真正由本体驱动的开发周期

我现在设想的流程,会在三个时刻介入。

开发之前:理解业务

收到新功能时,Claude Code 先识别出相关的本体概念。

它不需要加载整个本体。它可以挑出与需求相关的概念、关系和规则。

然后它检查这个功能是否与该模型兼容,或者指出需要做哪些演进。

开发就这样从对领域的明确理解出发。

开发期间和之后:检测漂移

一个机械式的分析器找出源代码的修改。

像 Tree-sitter 这样的工具,可以分析代码的语法结构并识别被修改的元素(这是我的下一个课题)。API 契约和 MCP 接口的演进,也能反映应用所暴露的能力。

LLM 借助这些要素,去查找与本体不一致的地方。

这项操作可以通过 hooks 集成到 Claude Code 的工作流中,比如在一次修改之后,或在任务结束时。

目的不是让 LLM 在每次变更时盲目重读整个应用,而是把分析集中在受影响的元素上。

集成之前:检查一致性

在代码合并之前,可以再做最后一次检查。

它会产出一份报告,列出:

  • 新增或修改的概念;
  • 可能受影响的业务规则;
  • 检测到的不一致;
  • 提议的本体修改;
  • 需要人工确认的决定。

目标是得到一项可重复的检查,精确到足以派上用场,又不会把每次代码修改变成对业务模型没完没了的评审。

保持概念与其实现之间的联系

另一项补充性的改进,是维持本体与代码之间的可追溯性。

像 Invoice 这样的概念,可以关联到参与其实现的多个类、函数、事件或 API 操作。

这些关联并不定义这个概念。它们指明的是它在哪里被实现。

这个区分能回答一些有意思的问题。

如果我修改发票这个概念,代码的哪些部分可能受到影响?

如果某个业务函数消失了,哪条本体规则可能不再被实现?

如果出现了新的 API 操作,它暴露的是一个现有概念,还是揭示了一个新观念?

如果一个类改了名,这只是单纯的重构,还是领域的实质性修改?

这份映射可以随着代码的演进逐步维护。

不过,它应当保留每项关联的证据:文件、符号和观察到的变更。LLM 推断出的关系,不应与已被证明的对应关系混为一谈。

从本体不变量到自动化测试

另一条思路,是让本体的一部分变得可执行。

有些业务规则可以表达为不变量。

例如:

  • 已确认的发票不能再修改;
  • 一张发票至少要有一行明细;
  • 红字发票要引用它所更正的发票;
  • 已取消的订单不能发货。

其中一些规则可以用来生成自动化测试,或者检查现有测试是否覆盖了它们。

这样就会得到两个互补的层次。

第一层是语义层:LLM 审视意图、概念与代码之间的一致性。

第二层是确定性层:可执行的测试和约束,检查那些能够形式化的行为。

因此,本体既不会取代单元测试,也不会取代集成测试。

它可以帮助解释为什么某些行为必须被测试,并找出仍缺乏检查的业务规则。

一份有生命的本体,而不是一份见风使舵的本体

这套机制有一个重大风险。

如果本体总是为了跟上代码而改变,它就不再是安全网,而沦为一份不断重新生成的普通文档。

反过来,如果它禁止一切与当前规则相矛盾的演进,就会让产品无法变化。

所以必须明确地管理本体的演进。

我区分三种情形。

演进是有意的,且清晰明确。 系统可以准备一份带版本的本体修改,甚至在确认之前先在工作分支上应用。

修改看起来与意图不一致。 系统提议修正代码,而不是更新本体。

意图含糊不清。 系统请求一个决定,而不是自行发明一条新的业务规则。

本体就这样成为意图与实现之间一份不断演进的契约。

这还意味着要保留历史记录,比如借鉴 ADR 的一个小型决策登记簿。一个被重命名的概念,不应变成两个互相独立的概念。一条被删除的规则,应当能关联到当初促成其消失的那项决定。

本体的演进应当和代码的演进一样可追溯。

衡量一致性,而不是统计代码行数

这种做法还可以产生几个有意思的指标。

本体覆盖率,衡量代码中已识别的业务概念里,有多大比例在本体中有对应的表示。

可追溯性,衡量有多少概念拥有可验证的、指向其实现的引用。

已确认但未解决的不一致数量,可以让人对代码与模型之间的漂移有个概念。

最后,关联到可执行测试的不变量所占的比例,有助于衡量安全网的牢固程度。

这些数字不会是绝对的质量指标。它们是否有价值,完全取决于系统能否把真正的业务概念与技术噪音区分开来。

但它们可以让某样至今仍大多隐含的东西变得可观察:软件在演进过程中的概念一致性。

如果这个过程能双向运行呢?

起初,我的做法是单向的。

代码产生本体。

后来我加入了反向的检查:本体用来检查新代码。

受 TDD 的启发,我又引入了前置步骤:在开始开发之前,先把意图与本体比对。

下一步演进,是把变化的检测和定性自动化,以便长期保持这种一致性。

但我现在看到了另一种可能。

代码可以推动本体演进,本体也可以引导代码的演进。

如果代码的某次修改让一个新的业务概念浮现,系统就提议把它纳入本体。

如果某个需求涉及现有概念的演进,本体能让我们在动手之前,就识别出可能受影响的规则和实现。

这个基准不再只是由软件产生。它参与了软件的变革。

我感兴趣的正是这个循环。

一个古老的想法,一种有待重新发明的用法

把 Ontology-Driven Design 说成一个全新的想法,是不符合事实的。

用本体来设计应用,由来已久。Pavel Hruby 早在 2005 年就描述过一种 Ontology-Based Domain-Driven Design 的做法。

更近一些,ODDToolkit 等工作探索了从形式化本体生成软件制品。

我的探索有些不同。

我并不一定要从本体生成软件。我也不想一上来就强制使用 OWL、RDF 或其他形式体系。

我想做的,是把业务本体用作让修改源代码的 AI 代理遵循的、有生命的一致性基准。

这个差别很重要。

业务模型不取代实现。它不自称描述软件的全部复杂性。它本身也不保证没有 bug。

它提供一个明确的参照框架,避免每个代理在每项新任务中,都重新构建它自己对业务的解读。

仍待证明的部分

我仍处于个人实验的阶段。

我先是从代码生成本体,然后请 Claude Code 依据它来检查代码的演进。接着我调整了指令,把这项检查前移到开发之前。

机械式的同步循环、系统性的可追溯性和自动化检查,是接下来的工作方向。

还有许多问题悬而未决。

在没有任何类名变化的情况下,分析器能否检测出真正的业务修改?LLM 会产生多少误报?JEV 能否满足这一需求?那是另一个课题,将来某天再开启。如何避免让本体塞满技术细节?概念与代码之间的对应关系,多久需要重新审视一次?还有最重要的:一致性的提升,能否抵得上这套机制的运行和维护成本?

这种做法需要在真实的软件演进中经受检验:包括有意的业务变更、人为引入的不一致,以及纯技术性的重构。

因此我并不自称已经定义了一种经过验证的新开发方法。

我描述的,是我正在试验的一个方向。

业务作为安全网

开发实践逐步增加了层层保护。

单元测试保护行为。集成测试保护交互。类型检查和静态分析工具能发现某些类别的错误。架构规则有助于维护软件的结构。

但当 AI 代理产出越来越多的代码时,另一个问题变得重要起来:

谁来保护这些代理所操作的业务模型的一致性?

DDD 长期以来给出了答案的一部分,包括通用语言、领域模型和上下文边界。六边形架构则有助于把业务与技术关注点隔离开。

我所探索的 Ontology-Driven Design,则是想在这些原则之上再添加一个可操作的机制:让业务模型显性化,把它与开发意图比对,再持续检查它与代码的一致性。

归根结底,我的目标不是产出更多文档。

而是让 Claude Code 能开发得更快,同时不会在每个功能中悄悄地重新发明业务。

代码仍是已实现行为的真相。本体成为业务含义的基准。意图则解释这个含义为何可能改变。

而一个用于 AI 辅助开发的新安全网,或许就诞生于它们彼此的比对之中。