很多人谈 ChatGPT、Codex、Pro、Plus 时，关注的是能力。

ChatGPT 能否稳定理解复杂问题。
Codex 能否持续参与真实代码库。
Plus 是否能覆盖日常工作。
Pro 是否能支撑长上下文、多阶段、高频任务。

但当这些能力进入真实工程后，一个更难的问题会出现：

AI 在不同时间、不同上下文、不同任务阶段里，能否保持一致？

这就是 AI Consistency。

也就是 AI 一致性。

在传统软件工程中，一致性通常指数据一致性、状态一致性、事务一致性和分布式一致性。

而在 LLM-Native 系统里，一致性的范围更广。

它不仅包括数据，还包括：

目标一致性
上下文一致性
决策一致性
代码一致性
接口一致性
测试一致性
记忆一致性
人机协作一致性

ChatGPT 前一轮确认的原则，下一轮是否还遵守？
Codex 修改前端字段后，后端、测试、导出和文档是否同步？
Pro 长任务中已经否定的方案，会不会后面重新出现？
Plus 日常工作流中已经固定的风格和格式，会不会突然失效？

这些都属于一致性问题。

当 AI 只是偶尔问答时，一致性问题不明显。
当 AI 进入长期任务和真实工程时，一致性会成为基础能力。

一、传统软件为什么如此重视一致性

传统软件系统里，一致性是最基础也最困难的问题之一。

例如一个订单系统执行支付流程：

用户付款
  ↓
支付成功
  ↓
订单状态更新
  ↓
库存扣减
  ↓
优惠券核销
  ↓
积分增加

这些步骤必须保持一致。

如果支付成功，但订单状态没有更新，系统就出现异常。

如果订单状态更新了，但库存没有扣减，就可能超卖。

如果支付失败，但优惠券已经核销，就会造成用户损失。

所以工程系统会使用：

数据库事务
幂等机制
消息队列
补偿事务
状态机
最终一致性
分布式锁

例如：

interface PaymentTransaction {
  paymentId: string;
  orderId: string;
  paymentStatus: "pending" | "success" | "failed";
  orderStatus: "unpaid" | "paid" | "cancelled";
  inventoryStatus: "reserved" | "deducted" | "released";
}

系统要保证这些状态不会互相矛盾。

AI 系统同样会产生大量关联状态。

只是这些状态不全存在数据库里，而是分散在上下文、任务计划、代码、测试、记忆和人工决策中。

二、AI 一致性不是“每次回答完全相同”

首先要明确，AI 一致性并不是要求 ChatGPT 每次都输出完全相同的句子。

大模型本身具有生成性。

同一个主题，可以有不同表达。
同一个问题，可以有不同分析路径。
同一个功能，可以存在多个实现方案。

真正的一致性，是关键约束和核心事实不能互相冲突。

例如，用户已经明确要求：

必须包含 ChatGPT、Codex、Pro、Plus；
文章使用 Markdown；
偏 CSDN 技术架构；
不要写成普通体验文；

那么后续文章可以换标题、换角度、换程序示例，但不能突然遗漏这些要求。

对于 Codex 来说，用户已经明确：

不修改数据库结构；
不引入新依赖；
不触碰支付模块；
先分析，再生成 patch；

那么后续执行方案不能违反这些边界。

因此，AI 一致性不是“输出固定”，而是：

在允许生成变化的同时，保持目标、事实、约束和系统契约稳定。

可以定义为：

interface AIConsistencyContract {
  invariants: string[];
  flexibleAreas: string[];
  forbiddenContradictions: string[];
}

例如：

const articleConsistency: AIConsistencyContract = {
  invariants: [
    "正文必须包含 ChatGPT、Codex、Pro、Plus",
    "文章应符合 CSDN 技术读者",
    "文章使用 Markdown",
    "内容必须偏工程化"
  ],
  flexibleAreas: [
    "文章标题",
    "技术角度",
    "代码示例",
    "章节组织方式"
  ],
  forbiddenContradictions: [
    "前文说只讨论技术，后文却变成纯产品体验",
    "前文强调人工验证，后文却建议 AI 输出直接使用"
  ]
};

这就是一致性契约。

三、ChatGPT 最常见的一致性问题：语义漂移

ChatGPT 的一致性问题，通常表现为语义漂移。

1. 目标漂移

用户最初要求：

写一篇适合 CSDN 的深度技术文章。

但经过多轮生成后，内容逐渐变成：

ChatGPT 可以提高效率；
Codex 可以帮助开发者；
AI 是未来趋势；

形式还在，技术深度却消失了。

这就是目标漂移。

2. 风格漂移

开始要求偏工程架构，后面却变成营销文、体验文或泛科技评论。

3. 约束遗失

前面要求必须包含 Pro、Plus，后面漏掉。

前面要求 Markdown，后面又输出普通文本。

4. 判断冲突

前文说：

Codex 修改核心模块必须人工审批。

后文却说：

未来 AI 可以自动完成整个开发流程。

如果没有条件限定，这两者就可能形成观点冲突。

这些问题不是内容生成能力不足，而是跨轮语义状态没有保持一致。

四、Codex 最常见的一致性问题：工程关系断裂

Codex 的一致性问题更严重，因为它会影响代码库。

一个工程改动通常不是单文件行为。

比如新增异常订单状态：

OrderStatus
  ├── 前端类型
  ├── 筛选组件
  ├── API 参数
  ├── 后端 DTO
  ├── 查询逻辑
  ├── 导出逻辑
  ├── 测试
  └── 文档

如果 Codex 只修改其中一部分，就会出现工程不一致。

常见问题包括：

前端字段新增，后端不识别；
后端枚举新增，前端类型未同步；
页面筛选生效，导出筛选未同步；
实现修改了，测试仍按旧规则运行；
测试更新了，业务文档没有更新；
接口返回变了，调用方仍使用旧类型；

这类问题本质上是关系一致性断裂。

可以把代码库抽象成一张一致性图：

type NodeType =
  | "type"
  | "component"
  | "api"
  | "service"
  | "test"
  | "document";

interface ConsistencyNode {
  id: string;
  type: NodeType;
  file: string;
}

interface ConsistencyEdge {
  from: string;
  to: string;
  relation:
    | "must_match"
    | "depends_on"
    | "tests"
    | "documents"
    | "shares_enum";
}

例如：

const orderStatusGraph = {
  nodes: [
    {
      id: "frontend-order-status",
      type: "type",
      file: "src/types/order.ts"
    },
    {
      id: "backend-order-status",
      type: "type",
      file: "backend/dto/orderQuery.dto.ts"
    },
    {
      id: "order-export-test",
      type: "test",
      file: "tests/orderExport.test.ts"
    }
  ],
  edges: [
    {
      from: "frontend-order-status",
      to: "backend-order-status",
      relation: "must_match"
    },
    {
      from: "backend-order-status",
      to: "order-export-test",
      relation: "tests"
    }
  ]
};

Codex 修改一个节点时，必须沿着一致性边检查相关节点。

五、Plus 场景的一致性：日常输出不能每次重新定义标准

Plus 更常见于日常任务。

例如：

写文章
整理资料
生成大纲
解释代码
总结会议
分析方案

这些任务单次风险不高，但频率高。

高频任务最容易出现标准漂移。

比如同一个系列文章：

第一篇是深度技术架构。
第二篇是普通科普。
第三篇变成经验分享。
第四篇又重复第一篇。

这说明日常工作流缺少稳定的质量标准。

Plus 场景可以维护一个轻量一致性配置：

interface PlusConsistencyProfile {
  taskSeries: string;
  requiredElements: string[];
  styleRules: string[];
  previousTopics: string[];
  prohibitedPatterns: string[];
}

例如：

const csdnSeriesProfile: PlusConsistencyProfile = {
  taskSeries: "ChatGPT Codex CSDN 深度文章",
  requiredElements: [
    "ChatGPT",
    "Codex",
    "Pro",
    "Plus",
    "程序结构",
    "明确技术判断"
  ],
  styleRules: [
    "偏软件工程",
    "避免浅层体验叙述",
    "使用 Markdown"
  ],
  previousTopics: [
    "LLM-Native Architecture",
    "Tool Contract",
    "AI Observability",
    "AI Testability",
    "AI Failure Recovery",
    "AI State Management"
  ],
  prohibitedPatterns: [
    "大段重复介绍 ChatGPT 是什么",
    "只强调效率提升",
    "无技术结构的趋势判断"
  ]
};

这样，日常任务可以变化，但质量标准保持一致。

六、Pro 场景的一致性：长期任务需要多版本协调

Pro 更适合高频、复杂、长上下文任务。

这种任务通常不是一次完成，而是不断演化。

比如一个大型项目可能经历：

需求版本 V1
  ↓
架构方案 V1
  ↓
代码修改 V1
  ↓
人工反馈
  ↓
需求版本 V2
  ↓
架构方案 V2
  ↓
代码修改 V2

此时最大的问题是：

哪些约束仍然有效？
哪些决策已经废弃？
哪些文件基于旧方案修改？
哪些测试对应哪个版本？
当前任务使用的是哪套上下文？

这就是版本一致性。

可以定义：

interface ProConsistencyState {
  taskId: string;
  activeVersion: number;
  goalVersion: number;
  contextVersion: number;
  codeVersion?: string;
  decisionVersion: number;
  testVersion?: string;
}

例如：

const proState: ProConsistencyState = {
  taskId: "order-refactor",
  activeVersion: 4,
  goalVersion: 3,
  contextVersion: 5,
  codeVersion: "commit-e4f5g6",
  decisionVersion: 3,
  testVersion: "commit-e4f5g6"
};

如果代码版本已经更新，但测试仍对应旧提交，就出现不一致。

如果目标版本已经修改，但上下文仍使用旧约束，也会出现不一致。

Pro 级任务不是上下文越长越好，而是各类状态版本必须协调。

七、AI 一致性的核心：定义 Invariant

传统软件中有一个重要概念：

Invariant

也就是不变量。

无论系统如何变化，某些规则始终必须成立。

例如银行账户：

余额不能无原因变成负数；
一笔转账的扣款和入账必须对应；
同一支付回调不能被重复处理；

AI 系统同样需要不变量。

例如 ChatGPT 写作任务：

必须围绕当前主题；
必须保留用户指定关键词；
不得违反禁用内容；
最终输出必须符合 Markdown；

Codex 工程任务：

不能修改禁止目录；
不能绕过失败测试；
不能在未经确认时修改数据库；
接口修改必须同步类型和测试；

可以定义：

interface AIInvariant {
  id: string;
  description: string;
  scope: "chatgpt" | "codex" | "plus" | "pro" | "shared";
  checkMethod: "schema" | "test" | "manual" | "scope";
  blocking: boolean;
}

示例：

const invariants: AIInvariant[] = [
  {
    id: "INV-001",
    description: "Codex 不得修改 payment 和 auth 目录",
    scope: "codex",
    checkMethod: "scope",
    blocking: true
  },
  {
    id: "INV-002",
    description: "文章必须包含 ChatGPT、Codex、Pro、Plus",
    scope: "chatgpt",
    checkMethod: "schema",
    blocking: true
  },
  {
    id: "INV-003",
    description: "失败测试不得通过修改断言绕过",
    scope: "codex",
    checkMethod: "manual",
    blocking: true
  }
];

没有 Invariant，AI 每一轮都可能重新解释规则。

有了 Invariant，系统才有稳定底线。

八、上下文一致性：所有结论必须基于同一事实版本

AI 系统常见的一个严重问题，是不同步骤使用了不同版本的事实。

例如：

步骤一读取旧接口文档；
步骤二读取新代码；
步骤三使用历史测试；
步骤四根据最新需求生成结论；

这样得到的方案很可能互相冲突。

上下文必须有版本和时间。

interface ContextVersion {
  contextId: string;
  source: string;
  version: string;
  updatedAt: string;
  status: "active" | "deprecated" | "uncertain";
}

例如：

const contextVersions: ContextVersion[] = [
  {
    contextId: "order-api-doc",
    source: "docs/order-api.md",
    version: "v3",
    updatedAt: "2026-07-01",
    status: "active"
  },
  {
    contextId: "old-order-spec",
    source: "docs/archive/order-spec-v1.md",
    version: "v1",
    updatedAt: "2025-04-10",
    status: "deprecated"
  }
];

系统在装配上下文时，应该优先使用 active 版本，并对冲突上下文报警。

这就是 Context Consistency。

九、决策一致性：已经否定的方案不能反复出现

长任务中经常会产生多个方案。

例如：

方案 A：完全重构订单模块
方案 B：增加适配层
方案 C：保持现有结构，小步修改

人工最终选择方案 C，并明确否定方案 A。

如果后续 ChatGPT 或 Codex 又重新采用方案 A，就出现决策不一致。

所以需要 Decision Registry。

type DecisionStatus =
  | "proposed"
  | "approved"
  | "rejected"
  | "superseded";

interface DecisionRecord {
  id: string;
  topic: string;
  content: string;
  status: DecisionStatus;
  version: number;
  reason: string;
}

例如：

const decisions: DecisionRecord[] = [
  {
    id: "DEC-001",
    topic: "订单模块重构范围",
    content: "保留现有结构，仅做低风险局部修改",
    status: "approved",
    version: 2,
    reason: "大规模重构风险过高"
  },
  {
    id: "DEC-002",
    topic: "订单模块重构范围",
    content: "完全重写订单模块",
    status: "rejected",
    version: 1,
    reason: "影响范围过大，测试覆盖不足"
  }
];

执行前必须检查：

当前计划是否违反 approved decision？
是否重新启用了 rejected option？
是否存在 superseded decision 被误用？

这就是决策一致性。

十、代码一致性：Codex 需要维护跨层契约

真实项目最容易出问题的是跨层契约。

例如一个接口字段：

interface OrderQuery {
  abnormalStatus?: string;
}

这个字段可能同时存在于：

前端表单
前端 API 类型
网络请求参数
后端 DTO
后端 Service
数据库查询
测试 Mock
接口文档

其中任意一处不同步，都会产生问题。

因此可以建立 Contract Consistency Check。

interface ContractField {
  name: string;
  type: string;
  required: boolean;
}

interface LayerContract {
  layer: "frontend" | "api" | "backend" | "test" | "doc";
  fields: ContractField[];
}

验证函数：

function compareContracts(
  contracts: LayerContract[]
): string[] {
  const violations: string[] = [];
  const base = contracts[0];

  for (const contract of contracts.slice(1)) {
    for (const field of base.fields) {
      const target = contract.fields.find(
        item => item.name === field.name
      );

      if (!target) {
        violations.push(
          `${contract.layer} 缺少字段 ${field.name}`
        );
        continue;
      }

      if (target.type !== field.type) {
        violations.push(
          `${field.name} 类型不一致：${base.layer}=${field.type}, ${contract.layer}=${target.type}`
        );
      }
    }
  }

  return violations;
}

Codex 在修改接口时，应该自动检查跨层契约是否一致。

十一、测试一致性：测试必须验证当前业务规则，而不是历史实现

测试也会出现一致性问题。

例如业务规则已经变化，但测试仍验证旧行为。

或者 Codex 为了让新代码通过，直接把测试期望改成新输出，却没有确认业务规则是否真的改变。

因此需要区分：

业务规则变更
实现方式变更
测试本身错误

测试不能简单跟随实现。

它应该跟随业务 Invariant。

例如：

interface BusinessInvariant {
  id: string;
  description: string;
  testFiles: string[];
}

const exportInvariant: BusinessInvariant = {
  id: "ORDER_FILTER_EXPORT_SYNC",
  description: "订单列表筛选和导出筛选必须保持一致",
  testFiles: [
    "tests/orderQuery.test.ts",
    "tests/orderExport.test.ts"
  ]
};

当 Codex 修改筛选逻辑时，系统应该检查这两个测试是否仍然共同保护同一规则。

十二、记忆一致性：长期记忆不能和当前事实冲突

ChatGPT 和 Pro 长任务可能使用长期记忆。

长期记忆很有价值，但也有风险。

例如记忆里保存：

订单模块暂不支持异步导出。

后来系统已经升级为异步导出，但记忆没有更新。

AI 后续仍基于旧记忆生成方案，就会出错。

所以记忆也需要一致性检查。

interface MemoryRecord {
  id: string;
  content: string;
  sourceVersion: string;
  status: "active" | "stale" | "conflicting" | "deprecated";
  lastValidatedAt: string;
}

当记忆和当前代码、文档或人工决策冲突时，应该优先信任更高权威和更新版本。

可以定义优先级：

用户当前明确指令
  >
人工确认决策
  >
当前代码和测试
  >
有效项目文档
  >
长期记忆
  >
模型推断

这就是一致性解析策略。

十三、多智能体一致性：ChatGPT 和 Codex 不能各自理解一套目标

ChatGPT 和 Codex 分工时，还会出现多智能体一致性问题。

例如 ChatGPT 理解的目标是：

只分析订单模块风险。

Codex 接收到的却是：

优化订单模块并生成 patch。

二者目标不一致，就会产生越权执行。

所以需要共享任务协议：

interface SharedTaskContract {
  taskId: string;
  goal: string;
  executionMode:
    | "analysis_only"
    | "draft_patch"
    | "safe_execute"
    | "approval_required";
  constraints: string[];
  acceptanceCriteria: string[];
  currentStage: string;
}

所有参与者都只能基于这份共享契约工作。

const taskContract: SharedTaskContract = {
  taskId: "order-analysis-001",
  goal: "分析订单模块可维护性风险",
  executionMode: "analysis_only",
  constraints: [
    "不得修改代码",
    "不得生成数据库迁移",
    "只输出影响范围和风险"
  ],
  acceptanceCriteria: [
    "列出核心文件",
    "标记高风险区域",
    "给出改进优先级"
  ],
  currentStage: "analysis"
};

ChatGPT 可以拆解任务。
Codex 可以读取代码。
但谁都不能越过 executionMode。

这就是多智能体一致性。

十四、一致性检查应该进入 AI Workflow Gate

复杂 AI 工作流不应该直接连续执行。

每个阶段都应该有一致性门禁。

Intent Gate
  ↓
Context Gate
  ↓
Decision Gate
  ↓
Execution Gate
  ↓
Verification Gate

每个 Gate 检查不同内容。

Intent Gate

当前目标是否和用户原始目标一致？

Context Gate

上下文是否来自同一有效版本？
是否存在过期或冲突信息？

Decision Gate

当前方案是否违反已确认决策？

Execution Gate

Codex 是否超出允许范围？

Verification Gate

代码、测试、文档是否同步？

可以定义：

interface ConsistencyGate {
  name: string;
  checks: string[];
  blocking: boolean;
  status: "pending" | "passed" | "failed";
}

只有 Gate 通过，任务才能进入下一阶段。

十五、一致性不是追求绝对统一，而是控制可接受分歧

AI 系统里并不是所有分歧都错误。

例如两个不同架构方案，都可能合理。

两篇文章采用不同结构，也可能都成立。

一致性管理不能把所有变化都禁止，否则 AI 会失去创造性。

所以需要区分：

允许分歧
禁止冲突

允许分歧：

标题不同
表达方式不同
方案候选不同
代码实现细节不同

禁止冲突：

目标相反
违反明确约束
接口字段不一致
测试和业务规则矛盾
使用已废弃决策

可以用一个简单模型：

interface ConsistencyPolicy {
  strictFields: string[];
  flexibleFields: string[];
}

例如：

const policy: ConsistencyPolicy = {
  strictFields: [
    "goal",
    "constraints",
    "accepted_decisions",
    "forbidden_scopes",
    "business_invariants"
  ],
  flexibleFields: [
    "wording",
    "implementation_details",
    "section_order",
    "candidate_solutions"
  ]
};

这才是合理的 AI 一致性。

十六、AI Consistency 与 CAP 思维

分布式系统中有一个经典问题：

Consistency
Availability
Partition Tolerance

AI 系统虽然不完全等同于分布式数据库，但也存在类似权衡。

例如长任务中：

• 要求每一步都强一致，会降低执行速度；
• 允许模型快速生成，会增加状态漂移；
• 多智能体并行执行，会提高效率，也会增加冲突。

因此 AI Workflow 可能也需要选择一致性等级。

type AIConsistencyLevel =
  | "eventual"
  | "session"
  | "strong";

interface TaskConsistencyRequirement {
  taskType: string;
  level: AIConsistencyLevel;
}

例如：

const requirements: TaskConsistencyRequirement[] = [
  {
    taskType: "brainstorm",
    level: "eventual"
  },
  {
    taskType: "technical_article_series",
    level: "session"
  },
  {
    taskType: "payment_code_change",
    level: "strong"
  }
];

头脑风暴可以接受更多分歧。
系列文章需要会话级一致。
支付代码必须强一致。

不同任务，不应该使用同一个一致性标准。

十七、未来代码库需要 Consistency Manifest

未来 AI-Ready Repository 可能不仅有上下文和规则，还会有一致性清单。

.ai/
  consistency/
    invariants.json
    contract-map.json
    decision-registry.json
    context-versions.json
    memory-policy.json

例如 invariants.json：

{
  "invariants": [
    {
      "id": "ORDER_EXPORT_FILTER_SYNC",
      "description": "订单列表筛选和导出筛选必须保持一致",
      "related_files": [
        "src/pages/orders/OrderList.tsx",
        "backend/services/orderExportService.ts",
        "tests/orderExport.test.ts"
      ],
      "blocking": true
    }
  ]
}

contract-map.json：

{
  "contracts": [
    {
      "name": "OrderQuery",
      "layers": [
        "frontend",
        "api",
        "backend",
        "test"
      ],
      "must_match": [
        "abnormalStatus",
        "dateRange",
        "page",
        "pageSize"
      ]
    }
  ]
}

这会帮助 Codex 在修改代码时主动维护跨层一致性。

十八、未来程序员的新能力：AI Consistency Engineering

过去程序员需要解决数据一致性、缓存一致性和分布式事务。

未来还会多一个领域：

AI Consistency Engineering

它包括：

目标一致性设计
上下文版本管理
决策注册与废弃
代码契约同步
测试与业务规则对齐
多智能体共享状态
记忆冲突解析
一致性 Gate 设计

这不是 Prompt Engineering。

Prompt 关注一次输入。
Consistency Engineering 关注整个系统长期是否自洽。

当 ChatGPT、Codex、Pro、Plus 进入复杂工作流后，这类能力会越来越重要。

十九、结语：AI 系统成熟的标志，是长期自洽

ChatGPT、Codex、Pro、Plus 让 AI 能够参与越来越复杂的任务。

但复杂任务真正难的不是生成，而是长期自洽。

ChatGPT 要保持目标和风格一致。
Codex 要保持前后端、测试、文档和接口一致。
Plus 要保持高频日常输出质量一致。
Pro 要保持长任务、多版本、多阶段状态一致。

AI 系统不需要每次都说完全相同的话。

但它必须做到：

核心目标不漂移；
关键约束不丢失；
已确认决策不被随意推翻；
代码契约不互相矛盾；
测试规则不跟随错误实现；
长期记忆不覆盖当前事实；

这才是 AI Consistency 的真正含义。

未来衡量一个 AI 系统是否成熟，不应该只看它一次能生成多好的结果。

还要看：

它能否在十轮之后仍然理解同一个目标？
它能否在多文件修改中保持系统一致？
它能否让 ChatGPT 和 Codex 共享同一份任务契约？
它能否发现上下文、代码、测试和记忆之间的冲突？

实验型 AI 追求一次惊艳。

工程型 AI 追求长期一致。

当智能开始参与软件生产，一致性就不再只是数据库问题。

它会成为整个 LLM-Native 系统的基础问题。