TL;DR

AI-Native 时代的架构决策需要新的记录方式:

  1. ADR 的局限 — 静态文档无法捕捉决策背后的推理过程
  2. AIDR 架构 — AI-Enhanced Architecture Decision Records,可验证、可追溯、可复用
  3. 决策即代码 — 架构决策用结构化格式记录,可被 AI 理解和执行
  4. 活的架构 — 架构文档与代码实现保持同步,自动验证一致性

关键洞察:架构决策的价值不在于记录结果,而在于记录可以复用的推理。


📋 本文结构

  1. ADR 的辉煌与瓶颈
  2. 为什么传统 ADR 在 AI 时代不够用
  3. AIDR:AI-Native 架构决策记录
  4. 实战:设计你的 AIDR 系统
  5. 决策即代码:可执行的架构
  6. 反直觉洞察:写更多文档,决策更快
  7. 工具链与实施路径
  8. 结语:架构的终极形态

ADR 的辉煌与瓶颈

什么是 ADR

Architecture Decision Records(架构决策记录)是 Michael Nygard 在 2011 年提出的概念,用于记录软件架构中的重要决策。

经典 ADR 格式:

# ADR 001: 使用 PostgreSQL 作为主数据库

## 状态
已接受

## 背景
我们需要一个关系型数据库来存储用户数据和订单数据...

## 决策
使用 PostgreSQL 15 作为主数据库

## 后果
### 正面
- 成熟稳定
- 丰富的生态
- 团队熟悉

### 负面
- 单点扩展性有限
- 需要 DBA 维护

## 替代方案考虑
- MySQL:生态类似,但团队不熟悉
- MongoDB:灵活性高,但关系型查询较弱

ADR 的价值

  1. 决策可追溯 — 知道为什么做出某个选择
  2. 知识沉淀 — 新成员快速理解架构背景
  3. 避免重复讨论 — 已有决策无需重新辩论
  4. 支持重构 — 理解决策边界,安全地修改

但问题也在积累

场景一:决策与代码脱节

架构师写了 ADR:”服务间通信使用异步消息队列”

半年后,开发者在代码里直接调用了 HTTP API。

代码审查时:

  • 开发者:”我不知道有这个决策”
  • 架构师:”ADR 里写得清清楚楚”
  • 代码:我按最简单的方式实现了

场景二:推理过程丢失

ADR 记录了”使用 Redis 作为缓存”,但没记录:

  • 当时评估了哪些缓存方案?
  • 性能测试数据是什么?
  • 如果数据量增长 10 倍,这个决策还成立吗?

场景三:无法验证

ADR 说”微服务之间不允许直接数据库访问”,但:

  • 如何检查代码是否遵守?
  • 有没有违规的实例?
  • 违规的后果是什么?

为什么传统 ADR 在 AI 时代不够用

问题 1:人类可读,但机器不可理解

ADR 是为人类编写的自然语言文档,AI 只能”阅读”但难以:

  • 理解决策的精确约束
  • 检查代码是否遵守
  • 在类似场景下复用推理

问题 2:静态文档,无法与代码同步

ADR 一旦写入就很少更新,但代码在持续演进。

结果是:ADR 描述的是”设计时的架构”,而非”运行时的架构”。

问题 3:推理无法复用

每个 ADR 都是独立的,无法:

  • 在不同项目中复用相似的决策逻辑
  • 基于历史决策训练 AI 做出更好的建议
  • 建立决策模式库

问题 4:缺乏验证机制

ADR 是”说明书”而非”契约”,没有强制力。

架构规范靠人自觉遵守,而非系统自动验证。


AIDR:AI-Native 架构决策记录

核心思想

AIDR(AI-Enhanced Architecture Decision Records)将架构决策从”静态文档”升级为”可执行规范”。

AIDR 的五个增强维度

AIDR 增强维度:
  
  1. 结构化 (Structured):
     传统: 自然语言描述
     AIDR: 结构化数据 + 自然语言解释
     优势: 机器可解析,AI 可理解
  
  2. 可验证 (Verifiable):
     传统: 人类阅读理解
     AIDR: 自动化验证规则
     优势: 代码是否符合规范,自动检查
  
  3. 可追溯 (Traceable):
     传统: 记录决策结果
     AIDR: 记录完整推理链 + 支持证据
     优势: 理解决策背后的 Why
  
  4. 可复用 (Reusable):
     传统: 每个项目独立
     AIDR: 决策模式库,跨项目复用
     优势: 相似场景快速套用
  
  5. 活的 (Living):
     传统: 写完后很少更新
     AIDR: 与代码同步演进
     优势: 文档永远反映真实状态

AIDR 格式示例

# AIDR-001: 服务间通信方式
aidr_id: AIDR-001
title: 服务间通信使用异步消息队列
status: accepted
date: 2026-03-14
authors: [architect-team]

# 结构化决策
decision:
  statement: 微服务间通信优先使用异步消息队列 (EventBridge)
  scope: 所有微服务间的非实时数据交换
  exceptions:
    - 实时查询场景可使用同步 HTTP
    - 内部工具可跳过

# 支持证据
evidence:
  requirements:
    - id: REQ-001
      description: 系统需要支持峰值 10k TPS
    - id: REQ-002
      description: 服务间需要松耦合
  
  alternatives:
    - name: 同步 HTTP
      pros: [简单, 实时]
      cons: [耦合度高, 级联故障风险]
      rejected_reason: 不满足松耦合要求
    
    - name: gRPC
      pros: [高性能, 强类型]
      cons: [学习成本高, 调试复杂]
      rejected_reason: 团队熟悉度不足
  
  metrics:
    - name: latency_p99
      target: "< 100ms"
      actual: "45ms"
    - name: throughput
      target: "> 10k TPS"
      actual: "15k TPS"

# 可验证规则
validation:
  rules:
    - id: VAL-001
      description: 服务间调用必须通过 EventBridge
      severity: error
      check: |
        // 伪代码规则
        for each service in services:
          for each call in service.outgoing_calls:
            if call.target_type == "service" and call.protocol != "EventBridge":
              fail("Violation of AIDR-001")
  
  tools:
    - static_analysis: custom-linter
    - runtime_check: service-mesh-policy

# 关联决策
related:
  supersedes: []
  depends_on: [AIDR-000: 微服务划分原则]
  superseded_by: null

# 影响范围
impact:
  services_affected: [order-service, inventory-service, payment-service]
  requires_changes: [重构现有 HTTP 调用]
  estimated_effort: 2 weeks

# 生命周期
lifecycle:
  review_date: 2026-06-14
  triggers:
    - 如果消息队列延迟 > 200ms,重新评估
    - 如果团队规模翻倍,考虑 gRPC

实战:设计你的 AIDR 系统

第一步:建立 AIDR 仓库

project/
├── src/
├── docs/
├── aidr/                    # AIDR 专用目录
│   ├── README.md
│   ├── templates/           # AIDR 模板
│   │   └── default.yml
│   ├── decisions/           # 具体决策
│   │   ├── AIDR-001-service-communication.yml
│   │   ├── AIDR-002-database-selection.yml
│   │   └── ...
│   ├── patterns/            # 可复用模式
│   │   ├── caching-strategy.yml
│   │   └── authentication-flow.yml
│   └── validation/          # 验证规则
│       └── rules/
└── .aidr-config.yml         # AIDR 配置

第二步:创建 AIDR 模板

# templates/default.yml
aidr_id: AIDR-XXX
title: "[简明扼要的标题]"
status: proposed  # proposed | accepted | deprecated | superseded
date: YYYY-MM-DD
authors: []

decision:
  statement: ""
  scope: ""
  exceptions: []

evidence:
  requirements: []
  alternatives: []
  metrics: []

validation:
  rules: []
  tools: []

related:
  supersedes: []
  depends_on: []
  superseded_by: null

impact:
  services_affected: []
  requires_changes: []
  estimated_effort: ""

lifecycle:
  review_date: null
  triggers: []

第三步:编写验证规则

// validation/rules/service-communication.js
const { RuleEngine } = require('@aidr/validator');

module.exports = {
  id: 'AIDR-001',
  description: 'Validate service communication uses EventBridge',
  
  async check(context) {
    const violations = [];
    
    // 检查源代码
    for (const service of context.services) {
      const calls = await analyzeServiceCalls(service);
      
      for (const call of calls) {
        if (call.targetType === 'service' && 
            call.protocol !== 'EventBridge' &&
            !isException(call)) {
          violations.push({
            service: service.name,
            location: call.location,
            message: `Service call to ${call.target} uses ${call.protocol}, expected EventBridge`,
            severity: 'error',
            aidr_id: 'AIDR-001'
          });
        }
      }
    }
    
    return violations;
  }
};

第四步:CI/CD 集成

# .github/workflows/aidr-validation.yml
name: AIDR Validation
on: [push, pull_request]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Validate AIDR format
        run: aidr validate --format
      
      - name: Check decision consistency
        run: aidr validate --consistency
      
      - name: Verify code compliance
        run: aidr verify --against=src/
      
      - name: Generate compliance report
        run: aidr report --output=aidr-compliance.md
      
      - name: Comment PR
        uses: actions/github-script@v6
        with:
          script: |
            const report = require('fs').readFileSync('aidr-compliance.md');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });

决策即代码:可执行的架构

架构即代码 (Architecture as Code)

AIDR 的终极形态是将架构决策变成”可执行的代码”。

# 架构决策不只是文档,而是系统的一部分

# 定义服务拓扑
topology:
  services:
    order-service:
      allowed_calls:
        - target: inventory-service
          protocol: EventBridge
          timeout: 5s
        - target: payment-service
          protocol: EventBridge
          timeout: 10s
      
      forbidden_calls:
        - target: user-service
          reason: "Must go through API Gateway per AIDR-003"

# 这些定义会被转换为:
# 1. 服务网格配置 (Istio/Linkerd)
# 2. 静态分析规则
# 3. 运行时监控告警
# 4. 文档自动生成

自动同步机制

AIDR 变更
    ↓
CI/CD 触发
    ↓
├── 更新服务网格配置
├── 更新静态分析规则
├── 更新监控仪表板
└── 更新架构文档
    ↓
代码仓库更新
    ↓
部署生效

违反即失败

// 运行时检查示例
const aidrEnforcer = require('@aidr/enforcer');

// 在服务启动时注册 AIDR 规则
aidrEnforcer.register({
  id: 'AIDR-001',
  enforce: (context) => {
    if (context.call.type === 'sync-http' && 
        context.call.target !== 'gateway') {
      throw new AIDRViolationError(
        'Direct HTTP call to service violates AIDR-001'
      );
    }
  }
});

// 拦截服务间调用
service.on('outgoing-call', (call) => {
  aidrEnforcer.check(call);
});

反直觉洞察:写更多文档,决策更快

洞察 1:文档成本 vs 决策成本

传统观念:写文档慢,不做决策快。

现实:

  • 写一个 AIDR:2 小时
  • 不做记录,3 个月后重新讨论同一个问题:8 小时 + 决策风险

AIDR 的 ROI:投入 2 小时,节省 10 小时,降低风险。

洞察 2:详细记录加速而非阻碍决策

反直觉:详细记录推理过程会让决策变慢。

现实:

  • 详细记录 → 推理清晰 → 减少反复讨论 → 决策更快
  • 详细记录 → 可复用 → 相似场景直接套用 → 决策更快

洞察 3:可验证的架构决策才有约束力

如果架构决策无法验证,就只是”建议”而非”规则”。

可验证性 = 约束力 = 架构一致性


工具链与实施路径

推荐工具链 (2026)

功能 工具 说明
AIDR 管理 AIDR CLI 命令行工具,创建、验证、查询
格式验证 JSON Schema / CUE 确保 AIDR 格式正确
代码验证 ArchUnit, Semgrep 检查代码是否符合架构规则
可视化 Structurizr, Mermaid 从 AIDR 生成架构图
决策支持 AI 助手 基于历史 AIDR 提供建议

实施路径

阶段 1:建立格式 (1-2 周)

  • 定义 AIDR 格式和模板
  • 创建前 3-5 个 AIDR
  • 建立评审流程

阶段 2:添加验证 (2-4 周)

  • 编写关键规则的验证代码
  • CI/CD 集成
  • 开始强制执行

阶段 3:全面采用 (1-3 个月)

  • 所有重要架构决策使用 AIDR
  • 建立决策模式库
  • AI 辅助决策建议

阶段 4:智能化 (3-6 个月)

  • 基于历史 AIDR 训练 AI
  • 自动识别架构违规
  • 智能决策推荐

结语:架构的终极形态

让我们想象架构的终极形态:

不是一张静态的架构图,而是:

  • 一套可执行的规则
  • 一个自我验证的系统
  • 一部持续演进的历史
  • 一种可以复用的智慧

AIDR 让架构从”画在纸上的设计”变成”活在系统中的决策”。

当架构决策可以:

  • 被机器理解
  • 被自动验证
  • 被跨项目复用
  • 与代码同步演进

架构才真正成为了工程,而不仅是艺术。


系列关联阅读

下一篇预告:#56 AI-Native 系统的可观测性进化:从日志到意图追踪


AI-Native软件工程系列 #53

Published on 2026-03-14