芥末
发布于 2025-09-22 / 0 阅读
0
0

用私域知识库让 AI 一次写出更贴合项目的代码

AI 编程最常见的问题,不是模型不会写 Java、Spring Boot 或 SQL,而是它不了解你的项目。

当你让 AI 写一个“订单退款接口”时,它通常能生成 Controller、Service、DTO、DAO,也知道要做参数校验、事务控制和异常处理。但真正集成到业务系统时,问题会立刻暴露出来:

  • VIP 用户退款是否免手续费?
  • 金额计算应该自己写,还是调用已有的 PriceCalculateService
  • 异常应该抛通用异常,还是使用团队里的 RefundExceptionErrorEnum
  • 审计日志要写到哪里?
  • 幂等键怎么生成?
  • 单测应该沿用 JUnit 5、Mockito,还是项目里已有的测试基类?

这些信息通常不在模型的通用知识里,而是藏在代码、接口文档、数据库字段、历史需求、团队规范和线上事故记录中。AI 缺少这些上下文,就像一个技术基础不错的新同事,刚入职就被要求独立改核心链路。

私域知识工程要解决的就是这个信息差:把项目里的业务规则、架构约束、编码规范和常见坑沉淀成结构化知识,再在 AI 编程时按需注入,让 AI 不只是“会写代码”,而是“按这个项目的方式写代码”。

AI 编程的 80 分困境

很多团队使用 AI 编程工具时,会经历类似流程:

sequenceDiagram
    participant Dev as 开发者
    participant AI as AI 编程工具
    participant Codebase as 业务代码库

    Dev->>AI: 帮我写订单退款接口
    AI-->>Dev: 生成通用退款接口代码
    Dev->>Codebase: 尝试集成
    Codebase-->>Dev: 业务规则不匹配
    Dev->>AI: VIP 用户有特殊退款规则
    AI-->>Dev: 修改业务判断
    Dev->>AI: 异常体系不对,要用 ErrorEnum
    AI-->>Dev: 修改异常处理
    Dev->>AI: 金额计算不能自己算,要调用已有服务
    AI-->>Dev: 再次修改
    Dev->>AI: 日志格式、单测风格也不符合规范
    AI-->>Dev: 继续调整

AI 往往能完成 80% 的通用代码,但剩下 20% 的项目适配会消耗大量时间。更麻烦的是,这 20% 往往正是线上稳定性和业务正确性的关键部分。

AI 默认擅长的内容AI 默认缺失的内容
常见框架用法当前项目的分层方式
通用代码模板团队异常码和日志规范
基础算法和数据结构业务公式和特殊规则
常见接口设计存量服务调用方式
单测基本写法项目已有测试基类和 Mock 习惯
数据库 CRUD表字段背后的业务语义

所以,提高 AI 编程质量不能只靠“换一个更强的模型”或者“把需求写得更长”。更有效的做法,是让 AI 在生成代码前拿到项目私有知识。

私域知识工程的整体结构

私域知识工程不是微调模型,也不是把整个仓库一股脑塞进上下文。它更像一个围绕项目知识构建的研发辅助系统,核心由三部分组成:

  1. 知识提取:从代码、文档、数据库、配置和测试中提取业务规则与工程规范。
  2. 知识注入:在 AI 编码时,把与当前任务相关的知识片段提供给模型。
  3. 知识维护:根据 Git 变更、需求变更和设计变更,持续更新知识库。

整体流程可以表示为:

flowchart LR
    A[代码仓库] --> D[知识提取]
    B[业务文档] --> D
    C[设计文档 / 接口文档] --> D

    D --> E[(私域知识库)]

    E --> F[AI 编程上下文]
    G[开发需求] --> F
    F --> H[生成代码 / 测试 / 文档]

    H --> I[代码变更]
    I --> J[文档自动维护]
    J --> E

关键点在于:AI 不需要记住整个系统,只需要在执行某个任务时拿到足够准确、足够相关的项目知识。

私域知识库应该包含什么

一个可用的私域知识库,不应该只是一堆零散 Markdown。它需要围绕“AI 写代码时需要知道什么”来组织。

推荐目录如下:

docs/ai-knowledge/
├── 01_architecture_overview.md      # 技术栈、模块划分、关键架构决策
├── 02_data_model.md                 # 核心实体、字段含义、表关系
├── 03_business_rules.md             # 业务规则、计算公式、边界条件
├── 04_terms.md                      # 业务术语、技术术语、命名约定
├── 05_development_standards.md      # 编码规范、异常处理、日志、测试要求
├── 06_common_pitfalls.md            # 常见问题、历史坑点、排查方式
├── 07_external_dependencies.md      # 外部服务、二方包、中间件、Topic、缓存 Key
└── maintenance/
    ├── document-maintenance-rules.md
    └── update-knowledge-prompt.md

每类文档关注点不同:

文档解决的问题AI 编码时的价值
架构概览系统由哪些模块组成,调用关系是什么避免新增不必要的层或绕过已有模块
数据模型字段含义、实体关系、状态流转避免误用字段、漏掉状态判断
业务规则公式、限制条件、特殊人群规则保证核心逻辑正确
术语词汇统一概念和命名避免同一个概念出现多个名字
开发规范异常、日志、单测、DTO 命名让生成代码符合团队习惯
常见问题历史 Bug、边界条件、规避方式避免重复踩坑
外部依赖RPC、消息、缓存、配置中心避免错误调用或漏掉依赖配置

如果只做一件事,优先沉淀业务规则和开发规范。因为这两类信息最容易影响生成代码能不能直接合并。

第一步:用 AI 反向解构代码库

很多项目的真实业务规则并不在文档里,而是在代码分支中。例如:

if (userService.isVip(userId)) {
    refundFee = BigDecimal.ZERO;
} else {
    refundFee = refundAmount.multiply(FEE_RATE);
}

这个判断背后其实是一条业务规则:VIP 用户退款免手续费。

代码解构的目标,就是让 AI 从实现中反向提取这些隐式知识,并整理成可复用的 Markdown 文档。

输入资料

知识提取时可以提供这些材料:

- 核心代码目录
- README / 技术设计文档
- 数据库表结构
- API 文档
- 配置文件
- 单元测试和集成测试
- 历史需求说明
- 运维手册、告警说明、排障记录

如果代码库很大,不要一次性把所有内容塞给 AI。可以按业务域或模块拆分,例如:

order/
refund/
payment/
user/
promotion/

每次分析一个模块,并带上已经生成的公共知识文档,避免上下文过载。

代码解构 Prompt 模板

下面是一个适合“系统分析 + 业务规则提取”的 Prompt 模板,可以根据项目技术栈调整。

# 角色
你是资深系统分析师和业务规则分析师,擅长从代码、配置、测试和文档中提取系统架构、数据模型、业务规则和开发规范。

# 目标
请分析我提供的代码和文档,生成可供 AI 编程使用的私域知识库文档。

# 分析重点
1. 系统架构
   - 技术栈
   - 模块划分
   - 核心调用链
   - 外部依赖:RPC、消息、缓存、数据库、配置中心

2. 数据模型
   - 核心实体
   - 字段业务含义
   - 状态枚举及流转规则
   - 表关系和关键索引

3. 业务规则
   - 条件分支中的隐式规则
   - 金额、库存、权限、状态流转等计算规则
   - 特殊用户、特殊渠道、特殊场景
   - 边界条件和异常场景

4. 开发规范
   - Controller / Service / Repository 分层方式
   - 异常类型、错误码、日志格式
   - DTO / VO / Entity 命名规范
   - 单元测试风格
   - 幂等、事务、并发控制方式

5. 风险与待澄清问题
   - 代码和文档不一致的地方
   - 无法确认的业务规则
   - 缺失的测试和边界场景

# 输出要求
请生成以下 Markdown 文档:

1. docs/ai-knowledge/01_architecture_overview.md
2. docs/ai-knowledge/02_data_model.md
3. docs/ai-knowledge/03_business_rules.md
4. docs/ai-knowledge/04_terms.md
5. docs/ai-knowledge/05_development_standards.md
6. docs/ai-knowledge/06_common_pitfalls.md

# 图表要求
涉及架构、调用链、状态流转时,使用 Mermaid 图。
图中不要堆方法签名,只保留模块、组件、外部依赖和关键业务语义。

# 约束
- 不要改写类名、方法名、字段名、枚举名。
- 业务规则必须给出来源位置,例如类名、方法名或配置项。
- 无法确认的内容不要猜测,放入“待澄清问题”。
- 输出内容要能直接作为后续 AI 编码上下文使用。

业务规则文档示例

生成后的业务规则文档可以采用这种结构:

# 退款业务规则

## 1. 手续费规则

| 场景 | 规则 | 来源 |
|---|---|---|
| VIP 用户退款 | 免手续费 | `RefundService#calculateRefundFee` |
| 普通用户退款 | 按退款金额乘以费率计算 | `RefundFeeConfig#feeRate` |
| 活动订单退款 | 需要扣除已使用优惠金额 | `PromotionRefundCalculator` |

## 2. 幂等规则

- 退款请求必须携带 `refundRequestId`。
- 同一个 `refundRequestId` 重复请求时,直接返回已有退款结果。
- 幂等记录存储在 `refund_request_record` 表中。

## 3. 异常规则

| 异常场景 | 异常类型 | 错误码 |
|---|---|---|
| 订单不存在 | `RefundException` | `ORDER_NOT_FOUND` |
| 订单状态不允许退款 | `RefundException` | `ORDER_STATUS_INVALID` |
| 退款金额超过可退金额 | `RefundException` | `REFUND_AMOUNT_EXCEED` |

这类文档比泛泛的“订单退款需要校验金额”更有用,因为它同时给出了规则、代码位置和异常规范。

第二步:让 AI 基于知识库写代码

有了知识库之后,AI 编程的调用方式要变。不要只输入一句“帮我写退款接口”,而是把任务、相关知识、输出要求和质量约束放在一起。

推荐上下文结构

[角色说明]
你是当前项目的资深开发工程师,必须遵循已有架构和规范。

[相关知识]
- 架构概览中的相关模块
- 当前业务域的业务规则
- 数据模型说明
- 开发规范
- 常见坑点

[开发需求]
新增商品订单批量退款功能,VIP 用户免手续费。

[输出要求]
- 给出改动文件列表
- 给出核心代码
- 补充单元测试
- 标注需要确认的问题
- 不确定时不要编造规则

[质量要求]
- 使用项目已有异常体系
- 使用已有金额计算服务
- 保证幂等
- 保证事务边界清晰
- 遵循现有日志格式

开发专家 Prompt 模板

# 角色
你是当前项目的资深后端开发工程师,熟悉 Java、Spring Boot、MyBatis、分布式事务、幂等设计和单元测试。

# 工作方式
你必须优先使用我提供的私域知识库内容,再结合代码上下文进行开发。
如果私域知识库和用户需求冲突,请指出冲突,不要直接猜测。

# 开发流程
1. 理解需求
   - 提炼业务目标
   - 拆分接口、服务、数据模型、异常流程、测试点

2. 检索并使用私域知识
   - 业务规则
   - 数据模型
   - 开发规范
   - 外部依赖
   - 常见坑点

3. 给出设计
   - 改动范围
   - 调用链
   - 事务边界
   - 幂等策略
   - 风险点

4. 编写代码
   - 遵循项目命名和分层
   - 使用已有异常类型和错误码
   - 使用已有日志格式
   - 复杂逻辑添加必要注释
   - 不随意新增依赖
   - 不绕过已有服务

5. 补充测试
   - 正常路径
   - 边界条件
   - 异常路径
   - 幂等场景
   - VIP 和非 VIP 差异

6. 自检
   - 是否符合业务规则
   - 是否符合开发规范
   - 是否存在并发和事务风险
   - 是否有待确认问题

# 输出格式
## 需求理解
## 使用到的私域知识
## 设计方案
## 改动文件
## 核心代码
## 单元测试
## 风险与待确认问题

示例:退款接口任务输入

# 私域知识
- 架构:订单域采用 Controller -> ApplicationService -> DomainService -> Repository 分层。
- 退款金额计算必须调用 PriceCalculateService.calculateRefund(...)。
- VIP 用户通过 UserService.isVip(userId) 判断,VIP 退款免手续费。
- 异常统一使用 RefundException,错误码定义在 ErrorEnum。
- 退款请求必须按 refundRequestId 做幂等。
- 审计日志写入 audit_log,日志事件类型为 REFUND_APPLY。
- 单元测试使用 JUnit 5 + Mockito。

# 开发需求
新增商品订单批量退款接口:
- 支持一次提交多个订单退款请求。
- VIP 用户免手续费。
- 非 VIP 用户按现有费率计算手续费。
- 需要返回每个订单的退款结果。
- 单个订单失败不能影响其他订单的处理结果。

AI 拿到这样的上下文后,生成的代码会更接近项目真实需求。它知道应该调用已有服务,而不是重新写一套计算逻辑;知道异常码在哪里,而不是自己定义一批错误字符串;知道批量退款要做单项失败隔离,而不是整个事务一起回滚。

知识库不是越多越好

把几十万行代码和所有文档全部塞进上下文,通常会降低效果。模型注意力会被无关信息稀释,反而漏掉真正重要的约束。

更合理的做法是按任务检索:

flowchart TD
    A[开发需求] --> B[识别业务域]
    B --> C[检索相关业务规则]
    B --> D[检索相关数据模型]
    B --> E[检索开发规范]
    B --> F[检索常见坑点]
    C --> G[组合 AI 编程上下文]
    D --> G
    E --> G
    F --> G
    G --> H[生成代码]

如果没有搭建检索系统,手动选择文档也可以。比如退款需求只需要带上订单、退款、支付、用户 VIP、异常规范和单测规范,不需要把库存、营销、物流模块全部带进去。

第三步:自动维护私域知识库

私域知识库一旦过期,AI 会基于旧规则写新代码,问题比没有知识库还隐蔽。知识维护必须和代码变更绑定。

推荐维护流程:

flowchart LR
    A[Git 变更] --> B[分析新增/修改内容]
    B --> C{影响哪些知识文档}
    C --> D[更新业务规则]
    C --> E[更新数据模型]
    C --> F[更新开发规范]
    C --> G[更新术语词汇]
    D --> H[质量校验]
    E --> H
    F --> H
    G --> H
    H --> I[提交文档变更]

Git 变更分析命令

可以用这些命令获取当前分支相对主分支的变化:

# 变更文件列表
git diff origin/master...HEAD --name-only --diff-filter=AMR

# Java 代码变更
git diff origin/master...HEAD -- '*.java'

# 配置文件变更
git diff origin/master...HEAD -- '*.yml' '*.yaml' '*.properties' '*.json'

# SQL 变更
git diff origin/master...HEAD -- '*.sql'

# Markdown 文档变更
git diff origin/master...HEAD -- '*.md'

这些变更可以交给 AI 分析,让它判断是否需要更新知识库。

文档自动维护 Prompt 模板

# 角色
你是当前项目的知识库维护工程师,负责根据 Git 变更增量更新 docs/ai-knowledge 目录下的文档。

# 输入
我会提供:
1. Git diff
2. 当前知识库文档
3. 文档维护规则
4. 可选的需求文档或设计文档

# 任务
请分析代码变更对私域知识库的影响,并更新相关 Markdown 文档。

# 分析重点
1. 新增或修改的类、方法、接口、枚举、配置项
2. 新增或变化的业务规则
3. 数据模型字段变化
4. API 请求参数和响应结构变化
5. 异常码、日志、监控、消息 Topic、缓存 Key 变化
6. 术语变化或命名不一致问题
7. 可能影响 AI 编程的常见坑点

# 更新规则
- 新增业务规则时,必须写明规则内容和代码来源。
- 新增数据字段时,必须补充字段类型、业务含义、使用场景和注意事项。
- 新增术语时,必须补充中文名、英文标识、定义、使用场景和代码示例。
- 修改已有规则时,保留变更说明,避免旧规则残留。
- 无法确认的内容放入“待澄清问题”,不要猜测。

# 输出格式
## Git 变更摘要
## 需要更新的文档
## 文档更新内容
## 一致性检查结果
## 待澄清问题

可以把维护动作放进开发流程

知识维护不一定要全自动合并。更稳妥的方式是让 AI 生成更新建议,由开发者在代码评审时确认。

推荐在 Pull Request 模板中加入一项:

## 私域知识库检查

- [ ] 是否新增或修改业务规则?
- [ ] 是否新增或修改数据模型字段?
- [ ] 是否新增或修改错误码、日志、监控、消息 Topic、缓存 Key?
- [ ] 是否需要更新 docs/ai-knowledge?
- [ ] 是否已运行知识库维护 Prompt?

这样可以把知识库维护变成研发流程的一部分,而不是靠某个人定期补文档。

一套可落地的产出结构

私域知识工程落地后,最终产物不只是几个 Prompt,而是一套能持续工作的知识体系。

私域知识工程产出
├── 系统架构知识
│   ├── 技术架构图
│   ├── 模块依赖关系
│   ├── 核心调用链
│   ├── 数据流与存储设计
│   └── 外部依赖清单
├── 业务知识
│   ├── 业务规则手册
│   ├── 业务公式手册
│   ├── 状态流转说明
│   ├── 专业术语词汇表
│   └── 常见问题与历史坑点
├── 工程规范
│   ├── 开发规范
│   ├── 异常处理规范
│   ├── 日志与监控规范
│   ├── 单元测试规范
│   └── 代码评审检查项
└── 自动维护机制
    ├── 文档维护规则
    ├── Git 变更分析 Prompt
    ├── 知识库更新 Prompt
    └── PR 检查清单

这套结构的价值不只在 AI 编程。新人熟悉项目、老系统重构、跨团队协作、故障排查,都能从这些文档里受益。

改造前后的开发方式对比

对比项普通 AI 编程私域知识工程模式
输入方式一句话描述需求需求 + 相关业务规则 + 项目规范
生成结果通用代码居多更贴合当前项目
业务规则需要多轮补充生成前已经提供
异常和日志容易不符合团队规范按知识库约束生成
代码集成需要大量手工调整主要检查细节和边界
文档状态和编码过程割裂随 Git 变更持续更新
适合任务小脚本、简单 CRUD复杂业务功能、存量系统改造

需要注意,私域知识工程不会让 AI 永远不犯错。它的目标是减少低级沟通成本,让开发者把精力放在设计判断、边界确认和代码评审上。

哪些场景适合做私域知识工程

场景是否适合原因
复杂业务系统适合业务规则多,AI 默认很难知道
存量代码库维护适合大量规则藏在历史代码里
多人协作项目适合规范统一后,AI 输出更稳定
频繁新增相似功能适合知识复用价值高
临时脚本不一定适合搭建知识库成本可能高于收益
纯探索性原型不一定适合规则尚未稳定,文档容易频繁推翻
安全限制极高的项目谨慎需要确认代码和文档能否进入 AI 工具上下文

如果项目还处在快速试错阶段,可以先只维护轻量知识:架构说明、核心术语、异常规范和几个关键业务规则。等业务稳定后,再逐步补全数据模型、调用链和常见坑点。

如何衡量效果

不要只凭感觉判断 AI 编程有没有变好,可以记录几个指标:

指标记录方式
首次生成代码可用率AI 首次输出后,能直接保留的代码比例
需求补充轮次从第一次输入到可合并代码需要多少轮对话
代码评审问题数业务规则、规范、测试相关评论数量
缺陷类型是否仍然出现规则遗漏、异常不规范、字段误用
文档更新滞后时间代码合并后多久更新知识库
单测覆盖情况AI 是否能补齐核心路径和边界测试

这些指标不需要复杂系统,开始时用表格记录就足够。真正有价值的是发现问题来源:是知识库缺规则,还是 Prompt 约束不够清晰,或者是需求本身没有说清楚。

常见坑

1. 把整个仓库都塞给 AI

上下文越多不等于效果越好。无关信息会干扰模型判断,尤其是多个模块存在相似类名、相似接口时,更容易生成错误调用。

更好的方式是按业务域检索,只提供当前任务相关内容。

2. 知识文档写得太空

类似“退款模块负责订单退款”这种句子,对 AI 编程帮助有限。知识库要写清楚规则、来源、例外和约束。

更有用的写法是:

VIP 用户退款免手续费。
判断方式:调用 `UserService#isVip(userId)`。
手续费计算入口:`RefundFeeCalculator#calculate(...)`。
注意:活动订单需要先扣减已使用优惠金额。

3. Prompt 只有人设,没有项目约束

“你是 20 年经验专家”只能提供风格暗示,不能替代具体规则。真正影响结果的是业务知识、代码约束、输出格式和自检要求。

4. 文档不维护

过期知识会让 AI 坚定地写出错误代码。知识库维护必须绑定 Git 变更、PR 检查或定期扫描。

5. 不让 AI 标注不确定项

AI 不确定时很容易补全一个看似合理的规则。Prompt 里必须明确要求:无法确认的内容放入待澄清问题,不要猜测。

6. 不做编译和测试验证

AI 生成代码后,仍然要跑编译、单测和静态检查。私域知识库能提高生成质量,但不能替代工程验证。

最小可行落地方案

不需要一开始就做完整平台。一个轻量版本可以这样启动:

第 1 天:
- 建立 docs/ai-knowledge 目录
- 写一份架构概览
- 写一份开发规范

第 2~3 天:
- 选择一个核心业务域
- 用代码解构 Prompt 生成业务规则和数据模型
- 人工校验关键规则

第 4~5 天:
- 用开发专家 Prompt 处理一个真实需求
- 记录生成质量和修改轮次

第 6~7 天:
- 增加 Git diff 文档维护 Prompt
- 在 PR 模板中加入知识库检查项

一个小团队甚至可以先只维护 4 个文件:

docs/ai-knowledge/
├── architecture.md
├── business-rules.md
├── development-standards.md
└── common-pitfalls.md

等实践稳定后,再拆分成更细的业务域文档和自动检索流程。

核心闭环

私域知识工程的关键不是“写很多文档”,而是形成闭环:

flowchart TD
    A[代码和业务规则] --> B[提取为私域知识]
    B --> C[AI 编程时按需注入]
    C --> D[生成更贴合项目的代码]
    D --> E[代码评审和测试验证]
    E --> F[根据变更更新知识库]
    F --> B

只要这个闭环能持续运行,AI 就会越来越像一个熟悉项目的协作伙伴。它仍然需要开发者判断方案、把控风险、验证结果,但不再需要反复解释那些项目里早已存在的规则。


评论