铃阅时讯
❌

普通视图

昨日发布 — 2026年11月17日 ⏭ 编程与技术开发

AI 写代码越来越快,谁来守住章法?

2026年11月17日 18:01

胡嘉乐 2026-11-17 18:01 浙江

AI 拉高了写代码的速度,于是必须有等比例的“约束机制”把质量兜住

这是2026年的第 82 篇文章

( 本文阅读时间:约 10 分钟 )

引言:

AI 写得快,但产出的是“狗屎代码”

Uncle Bob 在 8 月的一期直播中抛出一个判断:AI Agent 写代码确实快,但快不过它制造混乱的速度,产出常常是“狗屎代码”(messy code)。在不拒绝 AI 的前提下,他的解法是给 AI 套上确定性的约束。也就是用 CRAP 分数、环复杂度卡住代码质量,用变异测试验证测试本身够不够硬,再搭一条多代理流水线——Specifier 出题、Coder 写、Cleaner 清理、Hardener 加固、QA 验收,让几个 Agent 互相制约。

这场直播表达的核心观点可以概括为:AI 拉高了写代码的速度,于是必须有等比例的“约束机制”把质量兜住,否则速度就是负债。

01

痛点:AI 让“乱”通货膨胀

写代码的成本正在趋零,这意味着什么?意味着“乱代码”的产能也在指数级上升。要知道,以前一个人乱,是一个人的产能;现在 AI 来乱,是十倍的产能;而且 AI 乱代码有几个非常典型的模式,几乎每个用过 AI 写代码的人都见过。

1.1 功能实现为最高优先级,AI 才不管什么分包分层设计

图片

AI 往往只关注如何完成用户要求的功能,它未必了解项目的分层分包规范,对于个人维护的演示项目,这个问题尚可控制;但面向生产环境的项目如果缺少分层分包设计,代码仓库的腐化速度可想而知。

1.2 方法签名参数越来越多,补丁越打越多

图片

图片

Feature 迭代总是打补丁,总是在往一个方法里面加参数,总是在往一个方法体中加 if else 逻辑,AI 写代码只要能跑就行,方法的入参只会越来越多,if else 的嵌套也只会越来越多。

1.3 注释越写越长

当注释中混入 ADR、PR 链接等信息时,AI 生成的注释会越来越冗长。注释与代码不一致,还可能误导 AI 的后续判断。

图片

AI 特别喜欢写注释,这些注释中还会夹杂用户的澄清话术、ADR 以及 PR 的相关信息,有时甚至包含 AI 的思考过程。当 AI 写的注释和代码实现的逻辑不一致时,只会给 AI 带来更多的噪声。

1.4 AI 其实“不听话”

图片

明明已经在 CLAUDE.md 中标明了,AI 必须先完成代码审查,才能提交代码,可是为什么总是写着写着 AI 就会忘记了呢?这是因为,AI 存在幻觉,由于注意力机制的存在,当 Agent 的上下文越来越大的时候,注意力会被稀释,也就可能导致 AI 的表现变差。

02

思路:规则要硬,提示要明

2.1 规则要硬:制定架构分层规则

首先回答一个前置问题:AI 为什么不能像人一样“天然”知道该怎么分包分层?答案很朴素,因为它的上下文里没有。Architect.md 就是在 AI 的上下文中告诉 AI 该如何分层分包。

图片

图片

上图是 Architect.md 的片段,这份文件是项目架构规范的唯一真相来源。它基于真实项目结构,逐一定义了每个领域分包的职责边界,并把分层规则固化成几条硬约束:通用能力下沉到基础层(foundation),业务层只能向下调用领域层的组件与方法,反向依赖即视为违规。但有规范文件还不够,AI 看不到就不会用。因此我们在项目级 CLAUDE.md 中追加一条约束:AI 执行任何编码任务前,必须先读取并遵循 Architect.md。这一步把“代码该往哪放、依赖怎么走”从 AI 的猜测变成显式引导,让它按规范而非惯例产出代码。

2.2 提示要明:报错信息要告诉 AI 下一步怎么做

为了把问题说得更具体,我们切换一个更小的场景。当用户跑一段脚本,报错了,拿着堆栈去查原因,一个有经验的程序员看到 NullPointerException 会本能地做下一步:跳到报错行号,逐个审视这一行上哪些字段可能为空,顺藤摸瓜定位到上游哪里没赋值。这套动作对人是条件反射,程序员往往不会把这套排查步骤写成文档,因为这些步骤对他们来说太过显而易见。

但 AI 看到同样的堆栈,只会看到一串文本。除非我们在报错信息里明写“请检查第 N 行的字段空值来源”,否则它不会自动触发这套排查链路——它不缺少分析能力,但缺少“遇到 NPE 该先做什么”的默认动作。凡是希望交给 AI 的任务,都应把下一步操作写在 AI 最先能看到的地方;人靠经验补齐的隐式动作,AI 必须靠显式指令补齐。

图片

上述脚本挂在 git hook 的 pre-push 阶段。每当我们执行 git push,脚本会先介入检测;若质量门通过标记不存在或已过期,就拦截本次推送,并在报错信息里把话说完——质量门检测没有通过,并直接附上 AI 接下来该做的事,Step 1、Step 2 依次写清楚。如此一来,AI 拿到报错的第一时间就知道按序往下做,不必再猜测推送被拦截后该如何处理。

03

实战:ARCH-CHECK 如何给 AI 约法三章

基于上述思路,我们在真实项目中使用 ARCH-CHECK,将架构与代码规范转化为可执行的约束,用环复杂度卡住代码质量。下面介绍我们在真实项目中使用的工具:ARCH-CHECK。

3.1 ARCH-CHECK 工作流程

前文把方法论归结为一句话:给 AI 套上确定性的约束。ARCH-CHECK 就是这句话的产品化。一个 Maven 插件,把 Java 项目的架构与代码规则写成一份 YAML,并针对编译产物执行检查;一旦违规,它不只 fail 掉这次 build,还会把“下一步该做什么”直接写进违规信息,引导 AI 接着修。

图片

3.2 ARCH-CHECK 如何使用

快速开始

1.在项目根目录的 pom.xml 中添加以下 Maven 插件配置。

    <plugin>
      <groupId>com.anyi</groupId>
      <artifactId>arch-check-maven-plugin</artifactId>
      <version>xxx</version>
      <configuration>
        <rulesFile>${maven.multiModuleProjectDirectory}/.arch-check.yml</rulesFile>
        <report>text</report>
        <failOnError>true</failOnError>
        <verbose>true</verbose>
      </configuration>
      <executions>
        <execution>
          <id>arch-check</id>
          <phase>compile</phase>
          <goals><goal>arch-check</goal></goals>
        </execution>
      </executions>
    </plugin>

    2.在项目根目录新建 .arch-check.yml 文件。

    注意:需要将 group 的分包名称修改为你当前项目的分包结构和名称,下面的 yml 文件为参考配置。

      # arch-check rules —— 最简 MVC 分层
      # 依赖方向(全部 error): controller -> service -> dao -> model
      groups:
        controller: com.example.shop.controller..
        service:    com.example.shop.service..
        dao:        com.example.shop.dao..
        model:      com.example.shop.model..
      forbidden:
        - name: model-must-not-depend-on-others
          severity: error
          from: { group: [model] }
          to: { group: [controller, service, dao] }
          comment: >-
            Step 1: find the controller/service/dao types imported by the <from> classes.
            Step 2: move them up into the proper layer; model keeps only pure data.
        - name: dao-must-not-depend-on-service
          severity: error
          from: { group: [dao] }
          to: { group: [service, controller] }
          comment: >-
            Step 1: locate the imports of service/controller types inside dao.
            Step 2: move the business logic up to service; dao keeps only SQL/mapping.
        - name: service-must-not-depend-on-controller
          severity: error
          from: { group: [service] }
          to: { group: [controller] }
          comment: >-
            Step 1: move the shared type down to model or dao,
            and let controller call service forward.
        - name: no-circular-dependencies
          severity: error
          from: { group: [any] }
          to: { group: [any], circular: true }
          comment: >-
            Step 1: trace the cycle to find the A->B and B->A edges.
            Step 2: sink the shared types into a lower layer to remove the bidirectional reference.
      methods:
        - name: all-packages-max-5-params
          severity: error
          on: { group: [any] }
          assert: { maxParams: 5 }
          comment: >-
            Step 1: find the method whose parameter count exceeds the limit.
            Step 2: collapse the loose parameters into a single Request/Param object.
      messages:
        forbidden: "Violation: {from} depends on forbidden target {to}. {comment}"
        too-many-params: "Method {method} has too many parameters (limit {limit}, actual {actual}). {comment}"

      3.执行 mvn compile 触发架构分层分包校验。

      3.3 ARCH-CHECK 提供什么能力

      3.3.1 forbidden:反向依赖即红线

      From 组依赖 to 组即视为违规,例如领域层(core 层)不能反向依赖业务层(biz 层)的代码。检测到违规时,工具会同时输出 comment 中的修复指引,告诉 AI 下一步该做什么。这里指引信息的 Step 1(Step 1: consult the repo-root Architect.md (Layer Model / Dependency Rules / Directory Layout / Common Tasks) for the authoritative layering & packaging rules, and follow its placement before moving any type.)和上文的 Architect.md 文件相呼应。

        forbidden:
          - name: model-must-not-depend-on-others
            severity: error
            from: { group: [model] }
            to: { group: [controller, service, dao] }
            comment: >-
              Step 1: consult the repo-root Architect.md (layer model / directory layout)
              for the authoritative layering rules before moving any type.
              Step 2: find the controller/service/dao types imported by the <from> classes,
              and move them up into the proper layer;
              model keeps only pure data — no business types.

        3.3.2 methods:方法签名参数个数限制

        下面的规则对所有分组生效,所有方法签名都不允许超过 5 个参数,如果超过了则需要将这些参数抽象为 Request DTO 等等。

          methods:
            - name: all-packages-max-5-params
              comment: >-
                Step 1: find the methodwhoseparametercountexceedsthelimit.
                Step 2: collapse the loose parameters into a single Request/Param DTO
                placed in the appropriate layer, so the signature becomes (Request request).
              severity: error
              on: { group: [any] }
              assert:
                maxParams: 5

          3.3.3 calls:连“调哪个 API”都能禁

          例如,在生产项目中,应避免直接通过 java.util.concurrent.Executors 的工厂方法创建线程池,而应使用业务统一管理的线程池。

            calls:
              - name: no-executors-direct
                severity: warn
                from: { group: [service] }
                to: { member: "java.util.concurrent.Executors
            #new
            *" }
                comment: >-
                  Step 1: find the raw Executors.newXxx call site reported in the violation.
                  Step 2: replace it with a bounded shared thread pool,
                  and pass the pool explicitly — never the implicit ForkJoinPool.commonPool.

            3.3.4 types:拒绝太大的类

            当领域层或业务层中的某个类超过 900 行时,就该考虑拆分类或者提取方法了。

              types:
                - name: no-large-class
                  severity: warn
                  on: { group: [any] }
                  assert: { maxLinesOfClass: 900 }
                  comment: >-
                    Step 1: find the classwhosebodylinespan (bytecodeLineNumberTable) exceedsthelimit.
                    Step 2: split the class by responsibility, or extract collaborators.
                    (bytecode approximation, threshold intentionally lenient)

              3.3.5 comments:减少多余注释

              六种注释坏味道:被注释掉的代码、空/占位、复述代码的废话、过期 javadoc、过长行注释、过长 javadoc。

                comments:
                  excludes:
                    - "model/"
                    - "enums/"
                  rules:
                    - name: no-commented-out-code
                      severity: error
                      comment: "Step 1: dead code — delete or restore; note — keep it and state WHY."
                    - name: no-empty-placeholder
                      severity: error
                      comment: "Step 1: delete the empty/TODO comment, or state WHY."
                    - name: no-restating-comments
                      severity: error
                      comment: "Step 1: delete it, or rewrite as WHY — not HOW."
                    - name: no-stale-javadoc
                      severity: error
                      comment: "Step 1: sync or remove the javadoc tags that mismatch the signature."
                    - name: no-long-line-comments
                      severity: error
                      maxLines: 2
                      comment: "Step 1: condense consecutive // lines into ≤ 2 lines of WHY."
                    - name: no-long-javadoc
                      severity: error
                      maxLines: 2
                      comment: "Step 1: shrink the javadoc prose to ≤ 2 lines; keep the @tags."

                3.3.6 duplication:降低代码重复度

                使用 pmd-plugin 计算整个代码仓库的代码重复度,当重复率超阈值时,这段 comment 随违规一起输出。Step 1、Step 2 说白了就一句——定位重复代码,提取公共方法或基类,再修改各处调用,消除重复实现。

                  duplication:
                    maxRate: 10
                    comment: >-
                      Step 1: locate the Duplicate block in the report (file/line, redundant lines).
                      Step 2: extract the duplicated logic into a shared method in the proper layer,
                      or consolidate the near-identical classes.

                  3.4 ARCH-CHECK 实战效果

                  3.4.1 mvn compile/verify 强卡点

                  图片

                  3.4.2 方法签名参数过多,抽取通用方法

                  图片

                  3.4.3 方法嵌套层数过多,抽取方法解耦

                  图片

                  3.4.4 多余注释简化

                  图片

                  04

                   从“写代码”走向“定规矩”

                  AI 时代,整洁代码之道越发重要。代码落在哪一层、一个方法调哪条 API、一段重复代码怎么抽——这些事 AI 比新手写得快,也比新手写得齐。但它永远回答不了另一组问题:层为什么这么划?哪条依赖永远不许反向?Executors 为什么必须禁?参数上限定 5 还是 50?报错时,该如何告诉 AI 下一步做什么? 前一组是执行,后一组是规矩。执行正在被 AI 接走,但规矩没有,也接不走。规矩背后不是知识,是判断,是这个团队踩过的坑、是这个系统不能承受的事故、是“这次先这么定,出事了算我的”的那份担当。 所以你会发现一个越来越反直觉的事实:AI 写得越自由,规矩就得越硬。

                  以前的约束是软绵绵的,比如写在 Wiki 里、挂在嘴上、靠 code review 里的眼力。这套在人身上勉强够用,因为人会累、会不好意思、会被你盯着。可 AI 不会。它 24 小时满产能,唯一的刹车就是你给它的确定性栅栏。栅栏越不硬,它就越跑越快,你就越被它造的乱代码淹没。

                  人的位置因此往上挪了一格。不再亲手写每一行代码,转而写那 100 行左右、约束 AI 的 YAML:给层起名、给依赖划线、给方法定阈值、给 API 点名封杀、给报错配一句“下一步该做什么”。这 100 行看着少,分量却比以前写的任何 1000 行业务代码都重,因为它管的是 AI 接下来写的 10 万行。 ARCH-CHECK 这类工具,本质就是给人准备的这把椅子:我们坐在上面,决定要守住哪些规则,AI 在防线里自由跑。谁画赛道、谁在上面跑,分得越来越清。

                  延伸阅读

                  用于快速代码库理解的系统模板:https://architecture.md/

                  Matt Pocock 对话 Uncle Bob 直播回顾(YouTube):https://www.youtube.com/watch?v=zcLPGC-tvgk

                  图片

                  图片

                  欢迎留言一起参与讨论~

                  跳转微信打开

                  让数据按业务流动:EFS 数据流动重塑 AI 时代的文件存储

                  2026年11月17日 18:00

                  原创 火山引擎存储 2026-11-17 18:00 北京

                  01 | AI 业务提速,存储也要跟上节奏

                  随着大模型训练和推理业务高速发展、数据规模持续增长,提升业务效率不仅依赖算力,也需要与业务需求相匹配的存储能力。从训练样本读取、Checkpoint 写入与恢复,到推理服务启动、扩容时的模型权重加载,企业需要的不只是更多容量,更需要让高性能存储资源服务于真正需要它的业务环节。当前大模型训练和推理主要面临以下三类挑战:

                  • 性能需求多样化:Checkpoint 的写入与恢复需要在短时间内集中完成大规模数据读写,单个训练任务的存储带宽需求已从数十 GB/s 提升至 TB/s 级,而短期内不再访问的原始数据则对性能要求较低。

                  • 冷数据成本挑战:数据规模增长推高了高性能文件存储的容量需求与成本,且部分数据同时保存在文件存储和对象存储中,进一步加重成本负担。

                  • 复杂的数据生命周期管理:数据访问频率与冷热特征不断变化,仅依赖人工调度难以及时响应业务需求、准确识别数据冷热,还会带来较高的人力成本。

                  02 | 兼顾性能与成本,数据该如何组织

                  围绕容量成本与文件访问性能,常见方案有三个切入点:计算端缓存加速、在文件存储内部做冷热分层、在文件与对象之间建立数据流动。它们并非互斥的产品路线,也不是从低到高的三个层级;选择哪条路径,取决于数据已有的存放方式、应用接口以及团队可承担的管理工作。

                  2.1 计算端缓存加速

                  计算端缓存加速,将热点数据保存在计算节点本地或共享缓存中,减少对远端存储的重复读取。部分方案还支持计算端缓存写入,写入成功后将结果异步回写到持久化存储。在持久化完成前,若缓存发生故障且缺少有效保护,可能存在数据丢失风险。此外,部分基于对象存储的文件系统或缓存方案采用专有分块与元数据组织,后端对象无法直接作为原始文件使用,限制了对象接口访问及既有数据生态的复用。

                  2.2 文件存储内部做冷热分层

                  文件存储内部的冷热数据分层,将不同访问需求的数据分别放在高性能或低成本介质上,应用使用统一 POSIX 文件接口。它主要解决同一文件存储内的数据访问与介质成本问题,适用于以文件系统作为主要数据承载平台的业务。

                  2.3 数据流动:打通对象存储与文件存储的访问链路

                  数据流动连接对象存储的数据长期保存能力与文件系统的高性能访问能力:数据长期保存在对象存储中,业务通过 POSIX 文件接口访问所需内容;任务开始前按需预热,训练产生的新数据和结果沉降回对象存储,而不再需要长期保留在高性能存储中的文件数据则通过淘汰释放空间。

                  03 | EFS 数据流动:让存储配合业务节奏

                  火山引擎弹性文件存储(Elastic File Storage,以下简称 EFS),是面向 AI 与云原生的高性能文件存储,容量与性能可按业务规模弹性调整,满足 AI 训练、推理、数据分析等应用的高吞吐与高并发访问需求。

                  面向海量数据与不断变化的业务场景,EFS 数据流动将高性能文件访问、数据生命周期管理与业务调度结合起来,并与对象存储(Torch Object Storage,以下简称 TOS)协同,让数据按业务需要在高性能文件存储与低成本对象存储之间流转:需要使用的数据支持预热、按需加载或回源至 EFS,业务产生的结果可沉降至 TOS,冷数据则按策略释放 EFS 中的存储空间。结合细粒度任务控制、带宽调度与事件通知,数据准备、训练读写和结果保存可以自动衔接,让数据流转与资源使用更贴合业务节奏。

                  3.1 统一访问入口

                  EFS 支持数据按需加载和元数据按需加载(镜像回源),可将多个 TOS 桶中的海量数据组织为一个支持 POSIX 语义的高性能文件目录树。这使 EFS 成为 TOS 的高性能访问入口,打破了传统文件访问依赖数据全量搬迁的限制,提供了“数据长期保存在 TOS,业务通过文件接口按需访问”的新范式。对业务而言,这不是多一个挂载点,而是让训练、分析、推理和批处理能够以标准的 POSIX 语义直接使用 TOS 中的海量数据。

                  这一点对大模型和自动驾驶尤其重要。训练平台可继续以文件方式读取样本和 Checkpoint,数据平台仍可在 TOS 侧组织原始数据、标注数据和历史结果。文件访问和对象访问不再互相割裂,业务改造成本也更低。

                  3.2 自动生命周期管理

                  数据淘汰:EFS 数据流动支持根据文件的最后访问时间(atime)进行数据淘汰,当策略内的文件 atime 超过指定时间,系统会先将数据沉降至 TOS,保证数据完整性;再根据策略淘汰 EFS 中的数据或元数据。高性能存储空间随之释放,企业也无需为长期不再访问的数据持续承担文件存储的容量成本。

                  按需加载:当业务下次读取被淘汰的文件和 TOS 新写入的文件时,EFS 会按需加载 TOS 中的内容,不必先把整批数据全部预热至文件系统。数据可以长期低成本保存,业务仍以文件方式按需使用,既节省容量费用,也几乎不会因等待全量数据搬迁而造成计算资源闲置。对于需要提前准备的数据,还可以主动预热,减少首次读取的等待时间。

                  3.3 双向数据流动,数据按需访问

                  数据流动支持双向同步,业务可通过文件接口或对象接口读写同一份数据。在 EFS 中创建或修改文件,策略会自动将变化同步至 TOS;在 TOS 上传文件,策略也会自动将文件同步至 EFS,供训练、分析和推理使用。同时 EFS 支持可选配置“同步删除”:任一侧删除文件,另一侧关联的数据也会同步删除。

                  双向数据回源让业务无需等待提前同步,即可按需获取数据。训练任务可通过数据回源读取 TOS 中的样本,下游也可通过对象接口回源读取 EFS 中产生的 Checkpoint;文件内容或元数据淘汰后,仍可从原路径按需加载。对于需要提前准备或集中导出的数据,业务还可按目录、文件列表或属性条件提交一次性任务,让持续同步、按需访问与批量调度配合使用。

                  3.4 高吞吐,带宽智能调度

                  EFS 支持单实例百 GB/s 级数据流动能力,面向大规模样本预热和结果沉降,能极大缩短数据准备与保存所需的时间。EFS 将业务 IO 与数据流动 IO 队列隔离,并按 QoS 配置调度。当业务 IO 与数据流动 IO 都繁忙时,数据流动按默认带宽比例进行控制,避免批量预热或沉降无约束地争抢业务带宽。业务负载降低后,流动任务可借用闲置带宽,加快样本准备;流动任务空闲时,业务也可使用实例的全部剩余带宽。

                  3.5 自动化事件通知

                  EFS 支持数据流动任务的事件通知,自动将任务执行状态传递给业务调度系统。样本预热完成后,调度系统可自动启动训练任务;Checkpoint 导出成功后,可自动继续下游归档校验或分析。数据准备与结果保存由此成为可自动衔接的业务环节,减少人工跟踪进度和跨团队确认,避免数据已就绪、计算任务却仍在等待人工放行。

                  04 | 数据流动,到业务提效

                  EFS 数据流动让业务以熟悉的方式使用数据,使存储成本与数据冷热相匹配,并减少数据搬运和任务交接中的人工投入。

                  4.1 业务运行更灵活

                  双向数据流动让文件存储与对象存储协同处理同一批业务数据。训练、推理、分析和批处理通过 EFS 获得高性能、标准 POSIX 语义的文件访问;数据平台继续通过对象存储 S3 接口管理 TOS 中的原始数据和归档结果。业务可按场景选择访问方式,不必为不同系统反复导入导出数据,也无需把全部流程绑定到一种存储接口上。

                  4.2 冷数据成本可控

                  训练结束后,暂不再使用的样本和历史结果无需长期占用高性能存储。EFS 按策略先将数据沉降至 TOS,再淘汰文件内容、保留元数据,释放高性能空间。后续需要重训或分析时,业务仍从原路径按需读取。长期保存使用低成本存储,活跃数据使用高性能存储,整体存储成本最高可降低 80%。

                  4.3 性能资源按优先级使用

                  EFS 通过细粒度 QoS,让数据流动配合业务负载使用带宽。训练、推理等任务繁忙时,预热和沉降受控运行,减少对关键业务的影响;业务负载降低时,流动任务借用闲置带宽,加快样本数据准备和历史结果归档;流动任务空闲时,业务可充分使用实例的可用带宽。同一份性能资源随负载灵活分配,减少人工错峰和带宽闲置,兼顾业务运行与数据搬运效率。

                  4.4 流程编排更省心

                  EFS 通过事件通知,将数据流动任务的状态交给业务调度系统,任务完成后主动通知业务层,让下一步数据准备与计算任务自动执行。数据是否就绪、结果是否保存,成为业务流程可直接使用的调度信号。数据团队、平台团队和算法团队因此减少反复确认与人工交接,计算任务也不必在数据已准备完成后,仍需等待人工确认才能启动。

                  05 | 结语:让数据在流动中释放更大的价值

                  EFS 数据流动的产品价值,不在于单独提供一个数据导入导出的工具,而在于把 TOS、高性能文件存储和业务调度组织成一条可持续运行的数据链路。它为企业提供了一种新的泛文件访问方式:长期数据放在 TOS 中,业务需要时以 POSIX 语义高性能访问,阶段结束后再回到更经济、更适合长期保存的位置。

                  这也是 AI 时代文件存储要完成的升级:不只是存得下、读得快,而是让数据按照业务节奏自然流动。点击【阅读原文】了解更多!

                  阅读原文

                  跳转微信打开

                  让算力说同一种管理语言:共建 XPU 带外管理标准

                  2026年11月17日 18:00

                  原创 STE固件团队 2026-11-17 18:00 北京

                  摘要: 从算力模组到加速卡,从数据采集到诊断与升级,异构算力需要共同的带外管理语言。阿里、字节跳动、腾讯共同推动三份规范联合发布,以共同能力、协议与接口约定,降低跨厂商管理成本,面向业界开放共建、持续迭代。

                  XPU 模组标准化接口:共同语言,开放共建

                  一套算力集群接入了不同厂商的加速模组与加速卡。温度能读、功耗能看,设备也各有管理工具。可当链路降速、设备异常或需要批量升级时,运维团队仍然要翻阅不同的文档、切换不同的工具,为每一家厂商编写专门的处理流程。

                  这样的场景,揭示了异构算力基础设施的一道现实门槛:硬件形态和管理协议各有选择,但共同能力、数据含义和操作行为缺少一致约定,仍会带来反复适配。

                  围绕这一问题,阿里,字节跳动,腾讯三家云计算及AI服务商共同推动三份 XPU 带外管理规范的联合发布与开放共建,覆盖模组 Redfish 接口、卡级 PLDM/PDRs 定义,以及不带独立管理控制器的 XPU 带外能力。三份规范以真实工程需求为牵引,面向不同硬件形态,为跨厂商管理建立共同基线。

                  这项工作的目标很具体:让更多厂商、更多代际的算力产品,能够以一致、可验证的管理能力进入不同的基础设施,并在产业协作中持续完善,逐步形成业界广泛采用的标准。

                  1.算力越来越多元,管理复杂度也在增加

                  今天,一块加速卡或一个算力模组承载的管理对象,已经远远超出计算芯片本身。计算核心与显存是否健康?高速互联有没有降速?PCIe 链路是否出现错误?功耗、温度与保护状态是否正常?故障发生后,能否获取诊断证据并安全完成维护?这些信息共同决定着算力能否稳定交付。

                  XPU 是 GPU、NPU 及其他专用加速计算单元的统称。随着产品形态、供应来源和硬件代际增加,管理平台需要面对的差异也在累积:有的模组通过独立管理控制器提供服务,有的加速卡由服务器 BMC 直接管理;同一项指标可能有不同的名称和统计口径,同一种故障可能有不同的诊断能力,同一次升级也可能有不同的完成判定。

                  这些差异最终变成服务器集成、BMC 固件和运维平台中的厂商分支、专用脚本与重复验证。新产品接入要重新适配,旧产品升级要重新回归,故障分析还要重新拼接证据。

                  硬件多样性带来的价值,需要一套能够承接它的管理基础。

                  2.三份规范,让能力、表达与管理流程都有共同基线

                  此次一同推出的三份规范,从不同层面回应同一个问题:XPU 应具备哪些带外能力,这些能力如何被描述,又如何被管理系统一致地使用。

                  《XPU 模组标准化 Redfish 接口设计规范》:统一模组管理接口。

                  面向带有模组管理控制器的场景,规范基于 DMTF Redfish 技术体系,约定主机 BMC 与模组 BMC 之间的资源模型和操作行为,覆盖资产与健康、互联状态、事件通知、日志采集及固件升级等管理流程。通过共同的资源关系、数据语义和任务结果,帮助主机侧减少逐厂商适配,让模组状态可理解、维护过程可追踪。

                  《XPU 卡 PLDM 及 PDRs 定义规范》:统一卡级协议与数据描述。

                  面向 PCIe 标卡、OAM 等形态,规范明确带外通信通道与 PLDM 协议要求,覆盖部件资产信息、固件升级、加速器管理及诊断文件传输等内容。PLDM 是平台级数据模型协议;PDRs 是平台描述记录,用于描述管理对象、传感器和控制项,以及它们之间的关联。

                  规范进一步约定实体、传感器和控制项的标识与描述方式,使 BMC 能够按照共同规则识别、读取和使用设备能力,减少数据已传上来、含义却还需逐家解释的问题。

                  《XPU(不带 xMC)带外能力标准规范》:明确设备应提供的管理能力。

                  面向 PCIe 标卡,以及不带独立管理控制器、由服务器 BMC 直接管理的 XPU 场景,规范提出数据采集、固件升级、日志收集、电源与功耗管控、稳定性五类能力要求,并区分强制与推荐条目。它关注的是设备应提供什么能力,不定义 BMC 北向接口。

                  除了温度、功耗、显存错误和链路状态等采集需求,规范还明确升级包校验、升级结果查询、故障码与芯片诊断数据获取等要求,并约束高频访问、消息超时恢复及带外访问对带内业务的影响,让管理能力既可用,也能经受持续运行的检验。

                  三份规范分别明确能力要求、协议与数据描述、模组管理接口,形成相互补充的标准化基础。 不同硬件形态可以采用相应的管理路径,共同管理需求则有机会在更清晰的约定下实现和验证。

                  3.把共同能力标准化,为差异化创新留下空间

                  带外管理通过业务操作系统之外的管理路径完成状态采集和维护。对于模组,可以由模组管理控制器提供 Redfish 服务;对于卡级设备,可以通过 PLDM 等协议完成交互。不同形态有各自适合的实现方式,共同能力和语义则需要保持清晰。

                  三份规范的协作价值,在于把设备能力要求、通信与数据表达、管理接口约定分别明确,让固件侧、XPU 侧和运维侧能够围绕共同边界开展工作。硬件访问、驱动适配和内部实现仍由各方根据产品特点完成。

                  这也为创新保留了空间。厂商可以继续在芯片架构、互联技术、诊断深度和可靠性设计上投入,同时让共同管理能力以一致方式呈现。确需扩展的能力,应在相应规范的扩展与兼容约定下演进,保持已有数据和操作含义稳定。

                  规范的突破意义,在于把跨厂商管理从项目经验沉淀为产业共同能力。 共同约定越清晰,新产品进入基础设施所需的重复工作就越有机会减少。

                  4.让管理成本更可控,让更多算力进入开放生态

                  对于 XPU 厂商,共同能力与协议约定有望降低重复对接成本,让研发投入更多用于产品能力和可靠性。对于服务器与 BMC 厂商,更稳定的管理基线有助于减少逐型号分支,积累可复用的采集与维护流程。

                  对于云计算及AI服务商和最终运维,更一致的数据含义与操作结果,有助于统一资产管理、告警分析、诊断采集和升级编排。供应商选择也更有机会基于算力、可靠性和服务能力展开,减轻专用管理方式带来的集成负担。

                  管理标准化还可以为自动化运维提供更可信的数据基础。当状态、拓扑、错误与操作结果具有共同含义,规则系统和智能运维工具才能更稳妥地关联证据、提出处置建议,并核对处置是否生效。

                  共同规范不会自动消除所有硬件差异,也不会替代各家的驱动和软件生态。它能够做的是,让差异被清晰表达,让共同能力能够复用,让产业协作更容易持续。

                  5.三家云计算及AI服务商共同推动,让需求形成合力

                  阿里、字节跳动、腾讯长期面对大规模部署、持续维护和多供应商接入,其管理需求具有鲜明的工程特征:设备要能被发现,状态要可比较,故障要有证据,升级要可追踪,处置要能验证。

                  三家厂商共同推动这组规范,是把不同部署场景中的共性需求汇聚起来,为 XPU 厂商、服务器与 BMC 厂商提供更一致的实现方向。产业伙伴可以围绕共同基线建设能力,减少分别对接、分别验证的重复投入。

                  此次联合推出规范,也是面向长期共建的起点。未来,希望通过更广泛的产品实践和产业参与,推动规范的持续演进。

                  6.欢迎更多厂商参与,把规范变成能够运行的共同能力

                  一份规范的生命力,来自真实产品的实现、真实场景的检验,以及持续参与的建设者。此次三份规范将以草案为起点,在评审、实现与验证中不断完善。

                  欢迎 XPU 与模组厂商参与能力定义、协议实现和资源映射,将器件特性、诊断能力与边界条件带入规范;欢迎服务器、固件厂商贡献适配经验、参考实现和互操作用例,推动共同约定落地。

                  欢迎云计算及AI服务商、标准组织、行业伙伴与开发者参与评审、提出建议,推动规范走向更广泛的产业应用。

                  三家厂商的共建是起点,更多参与者的实践将决定标准能够走多远。期待通过开放协作与持续迭代,让这组规范逐步成长为业界共同认可、共同采用、共同维护的管理标准。

                  让不同的算力产品说同一种管理语言,让更多创新以更低的集成成本走向规模化应用。

                  跳转微信打开

                  用了AI就是“低端开发”?Syntax两位开发者:Vibe Coding成了骂人的话,认真做工程的人也被误伤了

                  2026年11月17日 18:00

                  原创 姜篇 2026-11-17 18:00 日本

                  CJ·雷诺兹:最近我用AI写了几乎所有代码,但决定仍是我做的。我安排它怎么干,也仍然是在做工程。

                  编辑 | 姜篇

                  CJ·雷诺兹:最近我用AI写了几乎所有代码,但决定仍是我做的。我安排它怎么干,也仍然是在做工程。

                  斯科特·托林斯基:不能因为一个项目用了AI,就把它整个扔掉。但那些未经修改、缺少判断的成品,确实一眼能看出来。

                  CJ·雷诺兹:代码库越清楚,AI越容易在里面工作。把所有决定都交给模型,并不会让工程问题消失。

                  这几句话出自AI Engineer CODE Summit 2026的一场对谈。对话的是Syntax的两位开发者成员:斯科特·托林斯基和CJ·雷诺兹。

                  备注:斯科特·托林斯基(Scott Tolinski)开发者播客Syntax的联合主持人,也是编程教学平台Level Up Tutorials的创办者。

                  CJ·雷诺兹(CJ Reynolds):Syntax的资深内容创作者,同时主持开发者节目Coding Garden。

                  他们一开始聊的是一个给Agent用的提示词,后来谈到代码结构、开发者技能,最后被现场观众问起了“Vibe Coding”这个词。

                  问题来了:当代码几乎都由AI生成,开发者还能决定它该怎么写、哪里不能改,以及什么结果可以交付吗?

                  下面按原视频翻译整理。

                  AI写了所有代码,他为什么还说自己在做工程

                  现场有观众问,到了2026年,“Vibe Coding”究竟是什么意思?这个词现在常被当成一句贬损:只要项目里用了AI,就有人认定它是随手写出来的。

                  CJ的回答有点拧巴,却很像开发者今天的真实处境。他起初也把Vibe Coding理解成“不关心代码,只管最后看起来像不像”。但他自己现在做项目,代码几乎全由AI来写。

                  CJ·雷诺兹:AI在写所有代码,可决定仍是我做的。我在安排整个过程,也仍然在做工程。我更愿意把自己做的事叫作“AI辅助工程”。

                  CJ谈“AI写代码,但决定仍由我做”

                  他所说的“决定”,不是按下生成按钮以后挑一版顺眼的结果。

                  前面聊到自己的CLI工具时,他已经举了例子:文件读写原本散落在代码库的十来个地方,他决定把它们收进同一个文件管理模块,再用Lint规则禁止直接读写文件。AI写后续代码,也得走这条路。

                  这也是他不愿给自己的工作贴上Vibe Coding标签的原因。AI负责实现,人仍然在决定系统该遵守什么约定。

                  “Vibe Coding”怎么成了一句骂人的话

                  CJ并不否认,有人真的会把AI输出原样扔进项目里。他反感的是另一个极端:看到“AI参与”四个字,就断定作品没有经过工程处理。

                  CJ·雷诺兹:我确实看到“Vibe Coding”被当作贬义词使用。有人贴出自己的应用,马上就有人说“这是Vibe Code出来的”,然后不再认真看它。

                  CJ谈“Vibe Coding”被当作贬义词

                  斯科特接过这个问题。他不理解为什么“用了AI”本身就足以否定一个项目;但他也承认,某些作品会明显暴露出没人继续编辑、没人检查细节、也没人对最后效果负责。

                  斯科特·托林斯基:我不赞成只因为用了AI,就把所有东西一概扔掉。可有些成品确实透着缺少打磨、缺少品味,也缺少对结果的掌控;这才是让人立刻失去兴趣的地方。

                  这段争论里,两人并没有给Vibe Coding定一条统一的词典释义。他们的意思是:评价一个项目,要看开发过程有没有人做判断,成品有没有人检查,而不是只查它有没有用AI。

                  想让Agent少走歪路,先把代码库理顺

                  对谈开头,他们聊到一个提示词:“找出应用里所有隐含的状态机。”这话听着玄,其实是前端代码里很常见的问题。

                  一个页面可能分别用isLoading、hasError、isSuccess几个开关表示状态。开关一多,“正在加载”和“已经报错”就可能同时为真,界面该显示什么,全靠散在各处的判断勉强支撑。把状态明确写成“加载中、成功、失败”,再规定状态之间怎样切换,开发者和Agent都更容易知道哪些情况不该出现。

                  斯科特·托林斯基:这些布尔状态可能把界面带进不可能的状态。把状态和转换规则明确下来,AI在这个代码库里写代码时,也就更不容易制造这种矛盾。

                  CJ随后把话题转向代码库本身。他遇到过一种流行说法:不用管代码长什么样,让AI决定就好。但他的实际经验恰好相反。

                  CJ·雷诺兹:我发现,代码库越整洁,AI在里面工作也越容易。代码里如果只有一处负责某件事,AI就更容易沿用它,而不是到处复制出第二套做法。

                  CJ谈代码库结构对AI工作的影响

                  他的CLI工具就是一个小例子:过去,写文件的逻辑散在约十处;整理之后,统一从文件管理模块进入。

                  但只告诉Agent“以后请用这个模块”还不够,下一次它仍可能直接调用文件系统接口。所以他加了一条Lint规则,禁止这种绕路写法。

                  CJ·雷诺兹:我把文件写入集中到一个模块,又加了规则,禁止直接调用文件系统读写接口。这样,AI后续改代码时,就必须使用已经定好的封装。

                  CJ说明Lint规则怎样约束Agent的文件读写

                  这不是要把AI调教成永不犯错,而是把团队已经做出的工程决定写进代码检查里。一个新同事加入项目,也要遵守同样的约定;Agent不该例外。

                  页面能跑,为什么还要看它怎么写的

                  有观众担心,开发者越来越依赖AI,会不会把自己的编程能力用废。斯科特没有劝大家死守每一项旧技能。他说,自己曾熟悉老版本浏览器的各种兼容技巧,现在忘了,并不影响做今天的网页。

                  但“旧技巧不再常用”和“开发者只剩输入提示词”,是两回事。

                  他们在对谈中说:有些手写技巧会过时,这很正常。但开发者不能因此把自己简化成只会不断输入提示词的人;为什么这样要求AI、结果又该怎样检查,仍然得想清楚。

                  两位开发者讨论技能变化与工程判断

                  斯科特举了一个让前端开发者很容易代入的情况:页面能正常显示,Lighthouse分数也不差;打开实现才发现,桌面端和移动端各复制了一整套DOM。现在看似能用,后面改一处内容,两个版本都得跟着改。

                  斯科特·托林斯基:应用运行得好好的,Lighthouse分数也不错。可你往里一看,整个DOM被复制了两遍,一份给桌面端,一份给移动端。这样的事仍然值得在意。

                  斯科特谈“能运行”与“写得合理”之间的差别

                  他不是说AI生成的页面一定会这样写,而是在提醒:浏览器显示正常,只说明眼前这次任务过关,不说明以后修改会轻松。

                  另一位主持人也提到现实压力:管理层要求“用AI、快点交付”,开发者忙着追赶工具变化,甚至没有余力思考自己究竟学会了什么、放弃了什么。问题未必只是个人有没有认真审代码,也与团队如何安排工作有关。

                  写在最后

                  临近结束时,有观众问:现在应用这么容易被复制,为什么还要发布自己做的软件?CJ的回答他正在做一款开发者工具,愿意花很多时间写文档,确保别人知道工具是什么、怎么用。他不想只把功能做出来,再随手让AI生成一份README就发布。

                  CJ·雷诺兹:如果真的为产品花了心思,用户会感受到。工具不只是一个GitHub链接;文档、使用体验,以及那些容易被忽略的小地方,都会影响他们愿不愿意继续用。

                  CJ·雷诺兹:做应用依然有机会,但你必须在乎它做得怎么样。

                  CJ谈应用发布后,开发者仍要认真打磨产品

                  回到开头那个问题,AI写完代码以后,程序员是否还管得住?两位开发者没有给出一套万能流程,但他们已经展示了几个具体动作:把状态定义清楚,把重复逻辑收拢,用规则守住代码库约定,检查“能跑”背后的实现,并把文档和体验当成产品的一部分。

                  代码可以交给AI写。至于什么该被写出来,什么不该混进项目,做完后是否值得交给别人用,这几步仍然需要有人在场。

                  参考链接:

                  跳转微信打开

                  拆解小红书存储底座 06|RedDB:小红书自研多模数据库的设计与实践

                  2026年11月17日 17:59

                  原创 REDtech 2026-11-17 17:59 湖北

                  从宽表实践到多模演进,解读 RedDB 的分层架构与核心设计。看一套数据库底座如何兼顾规模、弹性与访问效率。

                  导读

                  小红书的存储与数据库体系覆盖 MySQL、RedKV、Redis、ROS 等产品,DMS、RedDTS 等公共能力分别提供统一管控和数据传输支持。小红书存储与数据库团队依托自研的统一存储数据库云平台,为业务提供一站式数据基础设施。服务覆盖关系型数据库、缓存数据库、多模数据库及自研对象存储。RedDB 是其中面向多模方向建设的分布式数据库,目标是以统一底座支撑宽表、向量、图等数据模型与访问需求。

                  RedDB 从搜索、推荐和广告的宽表需求起步,逐步沉淀可复用的分布式与存储能力。本文先介绍分层架构和宽表实践,再展开模态接入、元数据、索引与查询协作的演进思路。最后,从平台运营、数据服务与引擎底座三个能力方向展望后续发展。

                  01

                  背景与目标

                  小红书的搜索、推荐和广告等业务,需要将丰富的内容与用户需求高效连接起来。随着内容理解与个性化匹配不断深入,业务对数据能力的需求也更加多样。既要快速读取内容属性和用户特征,也要利用语义信息与关联关系,让多种数据能力协同工作。

                  相应地,数据形态从结构化属性扩展到高维向量和实体关系。访问方式也从主键读写、条件过滤,延伸到相似检索与关系遍历。宽表、向量和图各有适合的数据模型与索引结构,对基础设施提出了多样化需求。

                  图 1:多模数据需求与公共底座的建设目标

                  不同模态的数据组织与计算方式各有特点。分片管理、副本复制、故障恢复和资源管理则具有共性。分别建设系统,会重复投入这些基础能力。多种模态协作时,还需要处理数据关联、更新传播与查询衔接。

                  RedDB 围绕分布式管理、数据服务协作、资源与运维三个方面建设公共底座。底座统一提供分片与副本机制,资源与运维依托统一云平台管理。建设从宽表起步,先验证读写、扩展与稳定性。后续将通过统一元数据与执行接口连接不同模态,逐步扩展向量、图等能力。

                  02

                  整体架构设计

                  宽表、向量、图等数据产品构成上层产品形态,RedDB 为其提供统一底座。RedDB 内部自上而下分为四层:数据服务、分布式引擎、存储与索引、数据持久化。平台运营提供横向管理能力。

                  图 2:上层数据产品与 RedDB 四层功能架构(虚线卡片为演进方向)

                  平台运营。依托统一存储数据库云平台(DMS),提供资源与集群管理,以及扩缩容、升级等标准化运维能力。安全与租户管理、监控与诊断贯穿数据服务及底座各层。

                  数据服务。位于 RedDB 内部最上层。数据模型组织数据与接口。查询计算负责查询执行、过滤与扫描,数据迁移衔接导入与同步。上层数据产品复用这些基础能力。当前以宽表为主要落地,后续将逐步接入向量与图。

                  分布式引擎。分片管理负责路由与分裂,弹性调度负责迁移与扩缩容。一致性复制通过 Raft 管理副本。故障恢复通过快照恢复与日志追赶重建副本状态。流量控制提供限流与反压,资源控制通过配额和并发限制约束资源使用。新模态可通过统一接口复用这六项能力。

                  存储与索引。负责物理数据布局、存储访问和索引组织。当前宽表采用基于 RocksDB 的行式引擎,承载行列读写与原子更新。列式引擎作为演进方向,用于适配不同的数据布局与访问模式。

                  03

                  宽表业务实践

                  宽表场景需要同时应对数据增长、字段稀疏、局部更新和高并发访问等挑战。RedDB 将总体架构落实为多项核心能力。分布式引擎支撑规模、弹性与稳定性,行式引擎优化写入语义和扫描效率。

                  图 3:宽表场景下的分片、弹性、稳定性与读写优化

                  分片管理。按主键范围组织分片,同一行的数据保存在同一分片内。复制、迁移和恢复都以分片为基本单元。数据增长后,通过分裂调整分片边界。分裂初期,父子分片共享底层存储引擎。逻辑分裂与物理迁移分开进行,以降低集中搬运数据的开销。

                  快速扩缩容。扩容时迁入分片副本。缩容时先迁出副本,再释放节点。每个迁移任务依次完成新增副本、同步追平、成员变更和旧副本退出。集群与磁盘两级并发配额控制迁移规模,兼顾迁移效率与在线负载。这套机制也支持节点替换和数据再均衡。

                  副本恢复。以 Raft 复制维护副本一致性,通过快照恢复与日志追赶重建数据状态。恢复以分片为单元推进,统一管理数据恢复与进度追赶。这套机制也为迁移和节点替换提供基础。

                  流量控制。在分片和节点两个层面,限制尚未完成的写请求。系统根据日志提交与应用的进度差触发反压,限制新增写入,避免请求持续积压。节点写并发额度为在线读取保留余量,降低集中写入对读服务的影响。

                  行级原子写。行式引擎支持局部更新。同一行的多字段写入由同一分片处理。写入经过 Raft 复制后原子应用,相关字段共同生效。读取时可按需指定字段,兼顾更新粒度与访问开销。

                  稀疏扫描优化。范围扫描可能遇到请求字段多、实际数据稀疏的情况。对此,RedDB 提供“先遍历已有列,再筛选请求字段”的访问路径。这能减少对缺失列的无效定位。扫描仍遵循既有的版本、删除和分页规则。系统也保留逐列定位方式,可按访问特征选择策略。

                  自上线以来,RedDB 已逐步落地搜索、推荐和广告等多个业务场景。围绕宽表访问特点,持续优化性能吞吐、成本费用与弹性扩缩容能力。

                  图 4:业务场景与性能吞吐、成本费用、弹性扩缩容收益

                  性能吞吐。用例覆盖 100 KB、500 KB 和 1 MB 行宽,以及单行读取、范围扫描和批量读取。在行宽、操作类型和并发档位一致的条件下,逐用例计算提升比例,再取中位数。RedDB 较对比方案的吞吐提升中位数超过50%,P99 延迟降幅中位数约为60%。

                  成本费用。成本对比采用 2026 年 9 月报告收录的资源报价,并按各自集群配置统一折算为月度费用。按此口径,RedDB 的集群成本较比对方案平均降低50% 以上。

                  弹性扩缩容。通过分片迁移和副本追赶,支持集群按需扩容、缩容与节点替换。迁移并发控制兼顾资源调整效率与在线业务负载。资源投入可随业务规模变化灵活调整。

                  宽表实践沉淀了可复用的分片、复制、调度与存储能力。向量、图等模态接入时,可以复用这些底层分布式机制。数据组织、索引维护和查询执行仍存在模态差异,需要通过进一步的接口抽象与执行协作来承接。

                  04

                  多模架构演进

                  RedDB 已面向键值(Key-Value)和宽表两类数据模型,抽象出统一的模态接入接口。以下介绍面向多模协作的演进设计,优先验证宽表与向量的协作。重点解决四个问题:模态接入、数据关联、更新传播和查询协同。

                  图 5:模态接入基础与元数据、索引及查询协作的演进设计

                  模态接入。主键编码、写入校验、日志应用和资源生命周期的差异,通过统一接口承接。分片、复制与恢复由公共框架负责。新模态围绕自身模型、索引和算法实现接口。存储层以现有行式引擎为基础,逐步扩展列式引擎。

                  统一元数据。元数据覆盖逻辑表、表结构(Schema)、主键和索引。它记录数据归属、字段关联与物理映射,也描述路由和引擎状态。同一份逻辑数据可对应多种物理表示,并通过统一主键关联。查询层据此衔接结果,索引管理据此跟踪构建与可用状态。

                  索引维护。主数据持久化,并记录可恢复的变更。索引侧消费变更流,衔接存量构建与增量追赶。系统管理处理进度和就绪状态,并通过幂等重放支持恢复,即重复回放不产生重复效果。主表提交后确认写入,派生索引更新完成后才对检索可见。这样可将索引维护与关键写入路径解耦。

                  查询协调。协调层读取元数据,结合过滤条件、候选规模和引擎能力选择计划。随后拆分子计划,并合并执行结果。过滤、检索和属性回读通过统一主键传递候选。执行时按需选择先过滤或先召回,并控制补充召回与结果数量。各引擎由此协作完成查询。

                  05

                  后续规划

                  后续建设将围绕平台运营、数据服务和引擎底座三个能力方向展开。目标是逐步形成服务更丰富、计算更高效、资源更灵活的多模数据库底座。

                  图 6:RedDB 后续规划(按能力领域组织)

                  平台运营:推进跨服务与跨资源治理。随着多模服务与独立计算资源逐步扩展,服务管理、租户治理和运行观测也需要进一步贯通。不同模态与负载由此获得一致的管理体验和服务保障。

                  数据服务:拓展多模能力与访问方式。从宽表逐步扩展向量、图等数据模型,完善相应的访问接口与服务能力。各模态保留自身特点,同时降低多种数据能力的组合使用成本。

                  引擎底座:增强存储与计算能力。在分片、复制与恢复等公共能力之上,沿存储与计算两条主线演进。存储侧推进存算分离,让容量与算力能够更灵活地独立扩展。计算侧增强跨模态计算与不同负载隔离。既让不同模态高效协作,也让不同任务获得相应的资源与服务保障。

                  RedDB 从宽表实践起步,持续解决数据增长、资源弹性与高效读写问题。可复用的分布式与存储能力,也在这一过程中逐步沉淀。未来,RedDB 将继续夯实公共底座、扩展模态接入、完善跨模协作。各模态保留自身的专用能力,数据组织、索引维护与查询执行则逐步打通,让统一底座能够持续承接新的数据需求。

                     .

                  作者简介

                  晓飞|小红书存储与数据库团队

                  分布式数据库技术团队负责人,关注数据库架构、业务交付与多模能力建设。

                  部门介绍:

                  存储&数据库部,为小红书全业务场景打造行业领先的存储和数据库产品及技术服务,兼顾高可用、高可靠、高性能与低成本。团队致力于建设精英化的组织,践行行业领先的技术理念。通过先于业务的布局和行动,为公司业务的快速发展提供充足支持,并推动小红书存储和数据库成为行业标杆。

                     .

                  招聘信息

                  分布式数据库研发专家:小红书招聘

                  图/表/向量/多模数据库等方向

                  精彩回顾:

                  拆解小红书存储底座 00|从孤岛走向融合:小红书存储与数据库架构进化

                  拆解小红书存储底座 01|多源数据传输总线 RedDTS 2.0

                  拆解小红书存储底座 02|让 AI 成为团队的一员:存储数据库助理实践

                  拆解小红书存储底座 03|从存得下到读得快:小红书自研对象存储实践

                  拆解小红书存储底座 04|从对象到文件:RedStore SSD 引擎与 RedFS 的设计与实践

                  拆解小红书存储底座 05|RedTAO 2.0:万亿级图数据库的设计与实践

                  跳转微信打开

                  登上GitHub Trending|腾讯开源 LoopForge

                  2026年11月17日 17:36

                  腾讯开源 2026-11-17 17:36 广东

                  云端自进化研发平台

                  单机 Coding Agent 写代码很快,但一旦走进研发团队,合盖断流、多人上下文割裂、Vibe Coding 质量失控、日常盯单耗时与同类问题反复踩坑,依然会把团队卡在“单兵提效、全局内耗”的瓶颈里。为此,腾讯轻量云团队打造并开源了云端自进化研发平台 LoopForge——集 7×24 小时云端工作区、多角色共享会话、工程级 SOP 流水线、无人值守自动化与 RSI 自进化于一体。目前平台正服务于 内部 20+ 业务,单月自动完成 200+ 需求与日常单据交付。本文结合 DeepSeek 最新的 Super-agent 探索,完整复盘背后的五步工程演进。

                  ▲ 需求进,MR 出:过程交给 Agent,人只在关键节点拍板

                  前两天,DeepSeek 团队发布了《Super-agent 设计探索:迈向更自主的 Agent 系统》并开源了研究原型。文章开篇点出了一个所有重度使用 Coding Agent 的团队都深有同感的痛点:模型单任务编码已经很强,但一个人同时盯三五个会话就到极限了——单个任务的质量受模型能力限制,而团队的多任务生产力,却被人的注意力死死卡住。

                  对比维度

                  DSH Super-agent 原型

                  LoopForge

                  核心定位

                  面向个人或轻量团队的异步工单调度原型

                  面向研发团队多人协同与工程交付的云端平台

                  交互与入口

                  浅层 Router 只做事件分发,不直接写代码

                  Main Bot 主副驾:小改动直接改代码提 MR,大需求派发 SOP

                  协作拓扑

                  单工单绑定单 Worker 独立干到底(跨角色协同留作开放问题)

                  产品 / 设计 / 研发同会话共享工作区 + 五层解耦多角色 SOP 流水线

                  中途接管

                  黑盒后台自治为主(中途如何介入与接管留作开放问题)

                  共享工作区随时 暂停 / 恢复 / 直接接管,支持在线 IDE 与终端介入

                  质量与演进

                  外部 Watchdog 监控 + 人工调整提示词(长程演进留作开放问题)

                  内环客观门禁当场自愈 + 外环工程级 RSI 自动复盘开处方改写 SOP

                  在构建 LoopForge(github.com/Tencent/LoopForge)的过程中,我们也走过了同样的探索之路。回顾整个系统的演进,我们并不是第一天就设计了一套庞大的架构,而是顺着团队真实落地的痛点,一步步跨过了五道坎:

                  阶段 1本地跑 Agent 合上电脑就断流走向云端运行

                  个人电脑跑长任务不敢合盖、多开分支容易卡死。我们把工作区与执行环境搬上云端,实现 7×24 小时持续运行。

                  阶段 2多人窗口孤立、跨角色靠人肉传话走向云端共享

                  团队各自对 Bot 聊天,需求、设计与代码上下文全靠来回复制粘贴。我们收敛为一个共享会话 + 一个 Main Bot + 同一个云端工作区,让全组在同一个现场协作。

                  阶段 3多人自由 Vibe Coding 质量难兜底设计工程级 SOP

                  自由对话改小需求快,但复杂工程容易“假装完成”或中途跑偏。我们把岗位能力拆解为带硬门禁、支持主副驾随时接管的工程级 SOP 流水线。

                  阶段 4例行事务与零散问题仍需人工盯守触发走向无人值守自动化

                  每次任务若都要人主动发起和盯进度,精力仍被日常巡检与零散单据切碎。我们构建了定时调度与事件驱动的自动化体系(如 Issue 自动修复实践),让后台真正无人值守。

                  阶段 5静态流程不长记性、同类问题反复踩坑走向工程级 RSI 自进化

                  写死的流程下次还会犯同样的错。我们落地了工程级 RSI 闭环,每次运行后自动复盘诊断并生成处方,反哺改写 SOP、角色与门禁,让系统越跑越聪明。

                  下面,就按照这五个阶段的演进顺序,把我们在 LoopForge 里的工程思考与实现完整拆解出来。

                  PART 01

                  从本地 Agent 到云端 7×24 小时运行

                  告别“合上电脑就断流”,把工作区与执行环境搬上云端

                  不管是 Claude Code、Codex 还是 CodeBuddy,最初大家都是在自己的笔记本电脑上打开终端跑 Agent。写单点功能的体验很爽,但一旦任务变长、变多,本地运行的物理瓶颈立刻就显现出来:

                  ●合上电脑就断流:跑一个耗时半小时的重构或全量测试,人不敢关机、不敢断网,下班合上笔记本任务直接中断。

                  ●本地环境重、并发受限:同时开三五个需求分支,本地端口冲突、容器把内存吃满,个人电脑根本扛不住多任务并行。

                  ●换台机器就丢现场:改了一半的代码、还没提交的分支和环境变量全锁在个人电脑里,换台设备或让同事帮忙看一眼都无从下手。

                  因此,我们的第一步很明确:把 Agent 的工作区和执行环境彻底搬上云端,让它脱离个人电脑 7×24 小时持续运行。为此,LoopForge 构建了三层云端运行底座:

                  1云端隔离工作区,全程免本地起环境:每个任务对应一个独立的云端容器或安全沙箱工作区,可同时拉取前后端多个代码仓库并自动切好工作分支。编码、编译、单测、联调与提 MR 全程在云上完成——本地不用再起开发环境,合上电脑下班,任务照样在云端跑到底。

                  2存算分离与自有机器一键接入:与 DeepSeek 将控制面与执行环境解耦的思路一致,工作区既可以跑在平台托管的云端容器里,也可以把团队的云主机或闲置开发机一键接入平台,7×24 小时在线接单。底层执行环境与具体编码工具解耦(支持自由切换 Claude Code、Codex、CodeBuddy 等),代码仓库凭证由网关按身份临时注入、任务结束自动擦除,模型全程接触不到明文密钥。

                  3自动快照休眠,随时无损唤醒:7×24 小时在线不等于 7×24 小时空烧算力。当云端工作区闲置回收或跨机器切换时,系统自动将未提交的代码修改与分支状态打包保存为云端快照;第二天回来继续对话时,系统自动从快照完整恢复代码现场。

                  PART 02

                  从个人单机到团队共享上下文

                  产品、设计、研发在同一会话围着 Main Bot 协作

                  当 Agent 能在云端 7×24 小时运行之后,使用方式很快从“个人自用”走向了“团队共用”。这时我们撞上了第二道墙:如果每个人还在各自孤立的窗口里跟 Agent 对话,团队的上下文依然是割裂的。

                  产品经理在自己的窗口里让 Agent 梳理了需求,设计师出了设计稿,到了研发手里,又得重新把背景、仓库分支和设计约束贴给自己的 Agent——单点编码变快了,但团队依然慢在跨角色的上下文搬运上。而如果为了共享上下文,直接把一堆 Bot 拉进群里自由群聊,又会导致消息刷屏、上下文互相污染,在多人对话里放开写权限还容易被他人随口发言误导引发越权操作。

                  为了让团队在云端真正共享同一个现场,我们做了两件事:

                  1共享会话 + Main Bot + 云端工作区

                  我们放弃了嘈杂的多 Bot 群聊,坚持“一个对话同一时间只绑定一个云端工作区,且只有一个 Main Bot 对接全组成员”。每次任务对应一个团队共享会话,产品、设计、研发直接进入同一个会话与 Main Bot 对话,成员换人发言时底层自动续接同一个会话上下文,操作的也是背后的同一个真实工作区。

                  ▲ 产品、设计、研发在同一个会话里,和同一个 Main Bot 对话

                  遇到改行文案、调个样式、修个小 Bug 这类日常需求,任何成员直接在共享会话里跟 Main Bot 说一句,Main Bot 当场打开云端工作区改代码、跑验证并一键提交 MR,全组实时可见、无需二次同步。

                  2独立审查模型代批 + 三挡权限放行

                  权限分级在多人共享会话里砍掉机械点“确认”,同时严防他人发言误触越权

                  原来的问题:所有写操作一刀切弹窗拦截,跑完一个任务要点十几次确认;但在多人共享对话里直接开全自动,又怕被群内他人随口一句话误导越权执行高危命令。
                  我们的做法:日常问候、代码只读查询与方案探讨直接自然语言收尾;涉及改代码、跑命令或提交 MR 时,按三挡权限模式精准放行:

                  每次确认稳妥受控

                  涉及修改的操作一律生成待确认草稿,人工确认后自动继续执行下一步。

                  智能代批风险自审

                  每次改代码、跑命令或提 MR 前,由无工具、无凭证的独立审查模型同时评估操作风险与当前发起人的授权意图(严格隔离群内其他成员发言与提示词注入,他人发言不能替当前操作人授权);常规操作自动放行,高风险或未授权操作自动转交人工确认。

                  完全自动高效直通

                  在授权范围内按顺序一次性自动执行完毕,仅在遇到破坏性冲突警告时强制拦截确认。

                  这样一来,常规读写与验证命令由独立审查模型代批秒过,只有越界或高危变更才找人拍板——既让产品、设计、研发在同一个云端上下文里畅通协作,又守住了多人共用的权限安全底线。

                  PART 03

                  从自由对话到工程级 SOP

                  五层标准 + 主副驾接管 + 工程级 RSI 自进化

                  当产品、设计、研发都能在同一个云端共享会话里围着 Main Bot 一起 Vibe Coding 之后,改小需求的体验已经非常丝滑。但一旦进入跨角色、长链路的正式迭代,自由 Vibe Coding 的质量失控问题就集中爆发了:

                  痛点 1流程随意、假装完成缺乏硬性工程门禁

                  在自由对话里,每个人提一句修改要求,Agent 顺着上下文一路乱改,没有标准的澄清、设计、评审与测试卡点;Agent 动不动自称“已改好”,实际连编译或单测都没跑通。

                  痛点 2跨角色交接靠聊天记录上下文膨胀且易丢细节

                  长对话越滚越长,上游对齐的边界条件被淹没在几十轮聊天记录里,下游编码时频繁漏改;正如 DeepSeek 消融实验所验证的,单靠提示词让一个 Agent 自发委派子任务,遇到复杂长尾就会退化成自己硬干。

                  痛点 3中途跑偏难接管、同类的坑反复踩缺乏受控介入与经验沉淀

                  任务跑到一半方向偏了,人在对话里强行插话容易把现场搞乱;而且这次花两小时修好的环境坑或规范问题,换个需求做 Vibe Coding 时还会一模一样再踩一遍。

                  我们意识到:小改动可以靠 Vibe Coding 拼手速,但严肃的研发交付,必须把专业角色能力与团队工程规范固化成带硬门禁的 SOP(标准作业程序)。在 LoopForge 里,我们通过三项核心设计把自由 Vibe Coding 升级为工程级 SOP 流水线:

                  1五层标准解耦:把专家能力固化为资产

                  我们不再靠临时提示词碰运气,而是在架构层面将专业岗位能力与 SOP 流程拆解为五层独立标准:

                  岗位角色角色能力定义

                  独立封装“架构师 / 前端 / 后端 / 测试”等岗位的职责说明、编码规范、专属技能与客观验证门禁

                  SOP 流程跨角色拓扑

                  定义澄清、设计、编码、测试等节点的先后依赖、并行分支与失败打回重做路径

                  执行引擎底层工具适配

                  自由切换 Claude Code、Codex、CodeBuddy 等编码工具,岗位能力与具体工具解耦

                  运行环境云端沙箱底座

                  绑定云端持久化容器、安全沙箱或团队自有机器,提供一致的执行环境

                  交付物契约阶段交接标准

                  明确上下游节点之间交接的结构化产物要求,保留完整历史版本

                  这些沉淀下来的专业角色资产全组共享:正式需求可以直接串成 SOP 流水线自动流转(每个节点只加载该岗位专属的规范与技能,并自动屏蔽仓库里杂乱的个人本地配置);而在日常共享对话中,成员也可以随时按需 @专家角色 进行独立的只读咨询,获取架构或评审建议并同步给 Main Bot 统筹处理,做到专业能力共享、平时绝不乱插嘴。

                  2主副驾三层秩序:自动驾驶与随时接管

                  引入 SOP 后,并不意味着人失去了掌控感。我们把协作收敛为可进可退的“人 ↔ Main Bot ↔ SOP 节点”三层主副驾结构:

                  ▲ 小事 Main Bot 直接改并提 MR;大事派发 SOP,可随时暂停、接管、恢复,测试不过自动打回

                  当 SOP 正在自动运行时,共享会话上方实时展示节点流水线,点击任意节点即可查看它的思考过程与执行日志。如果中途发现方向偏了,不需要去底层乱插话,除了可以在在线编辑器或终端里直接修改外,只需跟 Main Bot 说一声,就能按三种方式受控接管:

                  暂停介入

                  让流水线在当前节点安全停下,由 Main Bot 或研发直接修改文件、跑命令验证

                  恢复续跑

                  改完后带着修改说明恢复流水线,交还给后续节点继续完成测试与交付

                  直接接管

                  终止后续流水线,接管工作区已有成果,改完由 Main Bot 直接推送到原分支发起或更新 MR

                  3工程级 RSI:门禁自愈 + 复盘自进化

                  前沿 AI 领域一直在探索 RSI(Recursive Self-Improvement,递归自我改进)。但在真实的研发团队里,靠重新训练模型权重既不现实也太慢;我们真正落地的是工程级 RSI——让系统的执行轨迹反哺系统自身的 SOP、角色规范与验证门禁,形成“执行 → 客观检验 → 复盘诊断 → 改写流程 → 下一轮更准”的进化飞轮:

                  ▲ 第 1 次返工两次、55 分 → 复盘开出处方、新增门禁 → 第 2 次一次通过、96 分

                  1单次运行内环(客观门禁当场自愈):过去 Agent 写完代码全凭主观感觉声称“已改好”,报错还要人把日志贴回去让它重改。现在每个 SOP 节点内置编译、单测、代码规范等客观验证门禁——不通过绝不放行,Agent 拿着真实报错自动进入纠错循环当场修复(同时设有重试上限防止死循环),把低级错误直接消灭在节点内部。

                  2跨运行外环(递归复盘与资产自进化):传统流水线是静态的,这次踩过的坑下次还会照样再踩。在 LoopForge 中,每当一条 SOP 运行结束,复盘引擎会自动回溯全链路轨迹(各节点耗时、失败门禁、无效重复尝试与返工原因),给出 0~100 分健康度评分,并让 Agent 自己为 SOP 和角色开出结构化的“改进处方”:

                  进化流程拓扑改写 SOP 节点

                  针对容易卡壳或空转的环节,自动调整重试上限、失败回退路径与修复策略

                  沉淀防呆记忆改写岗位角色

                  把本次踩坑提炼出的经验与边界约束,自动追加到对应岗位的角色规范中

                  收紧验收卡点改写质量门禁

                  针对漏网的缺陷类型,自动为角色新增或升级客观校验门禁,堵死同类问题

                  人在界面上只需审阅处方、点一下「一键应用」,系统就会自动改写对应的 SOP 或角色资产并生成新版本。单次运行靠内环把代码改对,跨次运行靠外环把流程改强——团队今天踩过的每一次坑,明天都会变成整套研发流水线默认遵守的本能。

                  PART 04

                  定时任务与 Issue 全链路自动化

                  让日常 Bug 与 Issue 在后台自动排队、修复与提 MR

                  走完前三步,团队做重点需求时已经有了云端工作区、共享会话和高质量的 SOP 流水线。但任何一个处于快速迭代中的真实系统,除了主线大需求之外,每天还会源源不断地冒出大大小小的线上 Bug、体验瑕疵、技术债与零散 Issue。

                  过去处理这些日常 Issue 极其耗费时间和人力:单个问题看起来都不算大,但架不住数量多、来得碎——研发每天要花大量精力去需求池看单、认领、拉分支、定位修复、跑测试、提 MR;哪怕用上了 SOP,如果几十个零散 Issue 还要靠人一个个手动创建会话去触发、盯进度、解合并冲突,核心研发的整块心流依然会被切得粉碎。

                  我们思考的是:既然 SOP 已经具备了标准化的修复与验证能力,为什么不能让系统自己去巡检拉单、自己排队修 Bug、自己把改好的代码合并好送到人面前?但在把海量日常 Issue 彻底推向全自动处理的过程中,我们必须解决三个真实的工程卡点:

                  ●人工盯单派单成本高:缺陷单和体验问题散落在需求平台与代码仓库里,靠人肉巡检、手动复制上下文来启动 Agent,本身就是沉重的机械劳动。

                  ●多个 Issue 并行修复极易撞车冲突:十几个 Bug 单在后台同时改完,往同一个目标分支合并时频繁撞上代码冲突,最后还得把研发拉回来手动切分支解冲突。

                  ●个别卡点单子会堵死整条自动流水线:批量自动处理时,只要有一两个复杂 Issue 停在关键门禁等待人工确认,如果一直占着后台执行资源,后面的日常单子就全被堵住了。

                  为此,我们在第四阶段构建了定时巡检与 Issue 全链路自动化体系,把海量日常 Bug 与零散需求的消化过程彻底变成“后台无人值守流水线”:

                  01定时自动拉单与双向同步:新提的 Bug 单自动进入修复流水线

                  系统通过定时调度任务与需求平台、代码仓库双向打通,按周期自动巡检待办池里新提的 Bug 与 Issue,自动根据标签匹配对应的修复 SOP、拉起云端工作区开始定位与修复;执行过程中的阶段状态与最终生成的 MR 链接会自动回写到原单据下,研发不再需要手动去建单、派单和搬运状态。

                  02集成分支自动合流与冲突自愈:多单并行不再劳烦人工合代码

                  当同一批次的多个 Issue 并行修复完成、需要汇总合入集成分支时,系统会自动按序执行合并;一旦遇到代码冲突,不需要喊研发回本地救火,系统会自动提取冲突上下文,打回 SOP 的修复与验证节点自己解开冲突并重新跑通编译与单测门禁,全部验证通过后再统一生成汇总 MR。

                  03主动健康巡检与审批挂起零阻塞:7×24 小时吞吐不卡壳

                  除了被动修单,团队还可以配置定时巡检任务(如每日代码健康度扫描、依赖安全检查、构建失败自动排查),让 Agent 在发现隐患时直接生成修复方案。同时,流水线中任何需要人工拍板的单子,进入「待我确认」队列的瞬间立即释放后台执行资源,绝不阻塞后续大批量日常 Issue 的自动消化——真正做到海量日常小单子在后台 7×24 小时静默清零,人只需要在喝咖啡的间隙点一下最终验收。

                  SUMMARY

                  从个人工具到自演进组织的五步跨越

                  回看 LoopForge 的演进历程,如果借用自动驾驶的 L1~L5 分级来衡量研发团队落地 Agent 的深度,这五步恰好勾勒出了一条清晰的工程进阶路径:

                  ▲ 从本地单机工具走向云端共享、SOP 自治与自演进组织

                  L1问答工具

                  问一句答一句,代码靠复制粘贴,关掉窗口就结束。

                  L2个人本地助手

                  能在本地 IDE / CLI 里改代码,但环境与上下文锁在个人电脑里,合上电脑就断流。

                  L3云端运行与团队共享空间(阶段 1 & 2)

                  工作区搬上云端 7×24 小时运行,产品、设计、研发在同一个共享会话里对接同一个 Main Bot,配合独立审查模型代批高效协同。

                  L4工程级 SOP 与定时自动化流水线(阶段 3 & 4)

                  用标准化的 SOP、主副驾随时接管与客观质量门禁取代无序 Vibe Coding,并通过定时拉单与集成分支自动解冲突实现无人值守交付。

                  L5自演进研发组织(阶段 5 · 工程级 RSI)

                  每次运行后自动统计研发效能并复盘返工根因,把改进处方一键写回 SOP 与角色定义,组织流程越跑越聪明。

                  回顾整个探索过程,我们最大的一个体会是:让 Agent 真正成为研发团队里的靠谱同事,从来不是靠写一段更长的提示词,也不是靠拉一个热闹的多 Bot 群聊,而是把“人的工程经验”转化为“系统的运行秩序”。

                  在单机时代,我们把 AI 当作顺手的副驾驶,追求的是写出一段漂亮代码的即时爽感;但当它真正进入团队工程现场,瓶颈很快就从“模型会不会写代码”,转移到了环境会不会断、上下文怎么对齐、质量怎么兜底、以及人怎么从繁琐的调度里解放出来。

                  我们走过的这五步,本质上是一次次把“对人的依赖”沉淀为“工程机制”的过程:用云端工作区解开个人电脑的物理束缚,用共享会话与独立代批消弭跨角色的沟通鸿沟,用带客观门禁的 SOP 管住自由 Vibe Coding 的失控风险,用定时自动化实现后台无人值守,最后用工程级 RSI 跨运行复盘让整套体系自己进化。当团队每一次踩坑的教训都能自动沉淀为下一轮运行的门禁与规范时,我们收获的就不再只是几个会写代码的 Bot,而是一套真正属于团队自己、且每天都在自我进化的研发系统。

                  OPEN SOURCE

                  立即体验与支持

                  目前,LoopForge 已正式开源。我们把云端工作区调度、多人 Main Bot 共享会话、五层标准 SOP 编排、客观门禁自愈、定时与 Issue 全链路自动化以及工程级 RSI 复盘进化的完整实现全部开放出来,希望能为正在探索团队级 AI 研发落地的同行提供一份可直接上手、可二次定制的工程底座。

                  如果你也曾为“Agent 这次又跳过了测试”而头疼,或者希望团队的 AI 研发少一点重复交代、多一点经验积累,现在就打开 https://loopforge.cn/demo/ 浏览平台真实界面与交付记录,或者克隆仓库运行 bash scripts/install.sh,部署一套属于你们团队的 LoopForge,跑通自己的交付流程!

                  如果 LoopForge 对你有帮助,欢迎前往 GitHub 点亮一颗 Star,也欢迎提交 Issue 与 PR,和我们一起定义 AI 时代的软件交付方式!

                  开源仓库 · Tencent/LoopForgeGitHub ↗

                  https://github.com/Tencent/LoopForge/

                  扫描下方二维码加入 LoopForge 交流群:

                  跳转微信打开

                  职场新路子 | 谁懂天天审合同的痛?来看 Google 法务的秘密武器

                  2026年11月17日 17:30

                  Google Cloud 2026-11-17 17:30 北京

                  以下文章来源于谷歌云服务,作者 Google Cloud

                  合同审核、修改意见比对、流程跟进、汇报材料……法务工作中有不少重复又耗时的任务。Google 上海法务负责人姚迪分享他如何借助 Gemini,从合同风险审核、自动跟进进度,到搭建工作流生成报告,再通过 Deep Research 快速梳理新问题,让 AI 接手更多重复工作,也为专业判断和深度思考留出更多时间。

                  #Geminiagent#Gemini#GoogleCloud#AI办公#职场AI#AI工作流#DeepResearch#法务#合同审核


                  图片

                  图片

                  图片

                  跳转微信打开

                  模型一年换几代、团队还在各自为战?企业级AI原生引擎SoduWork正式开源:告别单兵作战,把经验彻底留在组织里!

                  2026年11月17日 15:11

                  原创 CSDN 2026-11-17 15:11 江苏

                  让 AI 从单兵作战走向智能协同,重塑企业级协作新范式

                  出品 | CSDN(ID:CSDNnews)

                  2026 年 11 月 16 日,由 MDiRi 数智建材研究院孵化的企业级 AI 原生引擎 SoduWork 召开全球开源发布会,宣布其自有核心代码正式按 MIT 协议开源。

                  过去两年,大模型从单点问答演进到自主智能体(Agent),底层技术日新月异。然而在企业真实协作场景中,技术热度与业务成效之间却出现了前所未有的断层:模型不断换代,但团队的协作效率并未成倍增长;AI 可以在瞬间生成海量内容,却往往夹杂着大量看似工整、实则无法直接交付的“工作废稿”;更普遍的现状是,员工好不容易调优的提示词与工作流,一旦换了工具或人员离职,整个组织又得从头教起。

                  针对“单兵提效无法汇聚为组织能力”的核心痛点,SoduWork 提出了 AI Know-how OS(企业级经验操作系统) 的全新架构,通过调度智能(Smart Dispatch)、治理闭环(Built-in Governance) 与 结果交付(Verified Delivery) 三大支柱,让 AI 从单兵作战走向智能协同,让流动在员工脑中的隐性经验转化为组织可复用、可审计、带不走的数字资产。

                  从单体智能迈向“智能体协同”与“多底座协同”

                  发布会伊始,IEEE Fellow、数智建材研究院总裁、前微软亚洲工程院院长刘震发表了题为《AI Agent 进化趋势:从单体智能走向可信协作》的开场演讲。

                  刘震指出,AI 智能体正在经历从“被动响应”到“主动决策与自主执行”的代际跨越。当大语言模型叠加了任务规划、工具调用与记忆机制,AI 就不再只是辅助敲键盘的个人效率插件,而是正在迈向多智能体深度协同、跨底层模型灵活调度的生产力新阶段。

                  “未来企业的核心竞争力,不再仅仅取决于拥有多少静态数据,而在于能够高效调度和协同多少具备高度自主决策能力的智能体集群。”刘震表示,面对底层大模型与工具链的快速迭代,企业不能被单一模型或单点工具绑架,真正高效的智能体体系必须支持多底座协同与跨平台调度。 这场变革并非简单的机器替代人工,而是一场全新的人机共创范式:人类负责设定愿景、划分边界、定义验收;智能体集群则在复杂约束下协同完成路径探索与自主执行。

                  正是基于这一前沿判断,SoduWork 将产品核心锚定在“智能体协同”与“多底座协同”两大方向——跳出单点对话与单一模型锁定的桎梏,一方面让多个智能体分工配合、相互校验,另一方面通过解耦架构实现跨模型、跨运行时的统一调度,直奔企业级组织治理的深水区。

                  三大支柱:重塑企业协作的 AI 原生引擎

                  承接行业趋势的演进,SoduWork 产品负责人晋为夷正式登台,代表团队向全球开发者发布企业级 AI 原生引擎 SoduWork。

                  “大模型和 AI 产品一年换好几代。上个月好不容易调顺的流程,换个工具可能又得重头再来。”晋为夷开门见山,道出了几乎所有企业在智能化落地中的共同困境,“与其每次都重新教 AI,不如把每一次人工纠正,沉淀成可复用的插件与标准流程,再在实际业务中不断补充规则、迭代升级,让经验真正留下来。”

                  在晋为夷看来,目前大量企业使用 AI 的方式依然停留在“单兵作战”阶段,AI 的价值绝不该仅仅局限于个人写几段文案、改几行代码的局部提效。“个人的局部提效,解决不了组织的协作断层。AI 真正深远的价值,是让个人的经验进入组织,让团队的方法能够共享、复用和持续迭代。只有多人与多个 Agent 深度协同,才能把个体经验沉淀为组织的长期资产。”

                  为此,SoduWork 围绕企业协作中最棘手的经验沉淀与交付断层,打造了一套 AI Know-how OS(企业级经验操作系统),通过硬核的技术架构打破协作孤岛,正式确立了支撑企业级协同的三大支柱:

                  1. 调度智能:换厨师,不换菜谱

                  技术迭代再快,企业的核心资产也不该被任何单一模型或平台绑架。当前行业正在面临严重的“平台与模型锁定”,SoduWork 采用弱依赖的解耦架构,率先接入并适配了 9 种主流 Agent 运行时(Harness),包括 Pi、OpenCode、Codex、Claude Code、Qwen Code、Kimi Code 等,并全面支持 ACP(Agent Client Protocol)协议标准。

                  “在 SoduWork 里,底座是干活的厨师,经验插件是做事的菜谱。”晋为夷介绍,菜谱只写一次,底座随任务挑选。企业不仅可以在同一流程中灵活调度高性价比模型处理基础初筛、调度顶尖强模型定夺关键推演,还能在某个工具额度耗尽或发生故障时,在同一会话中无缝切换到底座继续执行,上下文与文件资产丝毫不丢。

                  2. 治理闭环:让经验成为组织的版本

                  好方法如果只散落在员工个人的几十个对话框里,人一离职,经验便随之清零。

                  SoduWork 将治理能力深植于引擎内部。员工在日常工作中所调优的经验,可在会话中直接沉淀为“经验插件”。插件必须经过组织的标准化流转:本机预检 → 提交审核 → 发布者签名 → 组织级授权 → 审计追踪。 

                  未经审核的经验不可随意流通,安装权限不等于调用授权;任何插件的改进都生成新版本,旧版本与回溯日志完整保留。员工岗位变动,积累的方法依然沉淀在组织内部。

                  3. 结果交付:人做定义,AI 执行,人机协同验收

                  针对 AI 产出“看着工整、实际全错”且无人敢为结果签字的乱象,SoduWork 在流程中刻入了一条铁律:没跑过的检查,不算通过。

                  系统推行“执行与审查分离”的双 Agent 机制——负责执行的 Agent 不参与自检,由另一组 Agent 对照开工前明确的验收标准逐条初审,并强制留存工作底稿与核对证据。最终结果交由业务负责人确认验收,将不可控的模型生成转化为具备确定性的业务结果。

                  “今天,SoduWork 正式开启企业级智能生产力的新纪元。”晋为夷宣布,SoduWork 代码已全面开放,“我们真诚邀请全球开发者与企业立即下载体验、共建生态,让 AI 真正告别孤军奋战,即刻释放多智能体协同的无限潜能!”

                  落地见真章:经验即代码,经验即执行

                  技术能不能落地,关键看一线业务人员能不能用得起来。SoduWork 营销负责人邓景文在现场带来了核心功能与典型场景的实操演示。

                  演示表明,在 SoduWork 中,经验的沉淀不再需要技术人员专门编写复杂的工程代码,更不需要画复杂的低代码流程图:

                  • 对话即插件:业务骨干在处理复杂事务(如订单核对、异常投诉升级、供应链比价)时,只要在与 AI 的协作中纠正其偏差并把事情做对一次,即可通过内置助手将对话过程直接固化为具备工序、规则和验收标准的“经验插件”,耗时仅需几分钟。

                  • 即做即用应用:高频、重复的业务场景可以一键生成带有专属操作界面与 AI 侧栏的“即用应用”。复杂的业务逻辑(如多重变量叠加的报价计算)由随包脚本进行刚性约束,大模型专注于意图理解与交互,彻底告别纯大模型生成的计算偏差。

                  从制造效率评估到跨平台内容工厂,从复杂采购合规筛选到敏感数据本地脱敏流转,现场演示清晰展现了 SoduWork 如何将个人的最佳实践迅速转化为整个团队的战斗力。

                  高峰对话:企业 Agent 落地的“三道坎”

                  在技术圆桌环节,CSDN &《新程序员》执行总编唐小引与 CSDN 创始人&董事长蒋涛、清微智能创新技术副总裁何万青、SoduWork 技术 VP 叶丽文展开了深度对话。

                  讨论跳出常规的功能罗列,直面企业落地 Agent 避无可避的“三道生死坎”:

                  第一道坎:收得下(敢不敢验收 AI 的产出?)

                  当 Agent 可以在一小时内并发交出几十份结果,企业的审查负担却成倍加重。AI 产出的成果,企业到底凭什么敢收?

                  何万青用一个极具实战感的比喻打破了技术滤镜:“现阶段,最有效的方法是先把 Agent 当作‘外包员工’来管理。”他指出,不能只看着 Agent 在后台疯狂运行就默认它做得很漂亮,“管外包的核心是什么?开工前明确交付标准,过程中必须能跟踪、能干预,结束后全链路可回溯。没有完整的监督体系,效率越高,企业的隐性成本就越大。”

                  针对如何把关,叶丽文直接从工程底座上给出了回答。她认为,AI 的产出之所以不敢收,是因为缺乏确定性的验证锚点。“真正的经验沉淀,不能只是一段说明书式的 Skill,里面必须封装进测试用例、负面样例和验收标准。”叶丽文强调,只有让 Agent 的产出跑过预设的自动化测试,企业才能有底气收下交付物,即便未来底层切换了模型或算力,效果依然有据可查。

                  蒋涛则提醒企业必须放弃对单一工具的幻想:“不要只用一个模型,更不要只绑在一个工具上。用多模型、多工具去混合执行与校验,让不同的 Agent 互相纠错,才是让结果真正可靠的路径。”

                  第二道坎:签得了(出了事故谁来负责?)

                  当技术演进到“AI 开始修改自身代码与流程”,一旦这个循环脱离人工监管,出了事故究竟该由谁签字?企业级 Agent 该如何安全地“自进化”?

                  面对行业对“完全无人值守”的狂热,叶丽文冷静地泼了一盆冷水:“产品的自进化,绝不是一开始就追求百分之百的自动化闭环。”她指出,真正高效的路径,是先让团队里经验最丰富、技术最强的人去攻克复杂问题,把他们的最佳实践沉淀成可复用的经验包,再交给系统和其他人去跑。“让系统逐步具备自主发现和解决问题的能力,这需要持续迭代,绝不能盲目把控制权全交出去。”

                  何万青则描摹了人机协同演进的终局模型:“未来的公司可能只需要三样东西:数据库、知识库,以及由‘人与硅基智能结合’的数字员工。 数据库存数据,知识库沉淀方法。遇到新业务,就基于旧经验迭代出新插件。”他强调,自进化的核心不是替代人类,而是把员工在业务实战中烧脑积累的真经验,源源不断转化为组织的共有智能,反哺 AI 变得更强。

                  在这场协同中,蒋涛的观点一锤定音:“无论机器怎么演进,‘人负责定义验收、为人机协同的结果签字’这一环绝不能被架空。”

                  第三道坎:带得走(沉淀的资产会不会被锁死?)

                  近期头部厂商企业级 Agent 平台的调整与停服风波,让资产锁定成为了全场最沉重、也最现实的话题。企业几年间积累的工作流、记忆与经验,究竟能不能带得走?

                  蒋涛切中要害地指出,企业最宝贵的技术资产不是外部的工具账号,而是探索过程本身:“最核心的事,是把你的意图、对话和上下文妥善存储并管理起来。”蒋涛直言,一旦账号被封、软件下线、模型不再可用,别人之前生成的结果就彻底丢失了;“但只要你把整个推演的过程完完整整保留在自己手里,哪怕原来的平台明天就关停,这些经验和工作流仍然可以在新环境里迅速复刻出来,甚至能以更低的成本做得比原来更好。”

                  “今天好用的工具,明天可能就会停服。”叶丽文直截了当地点明了开源与自部署的战略意义,“正因如此,企业必须把协同引擎部署在自己的环境中,支持解耦接入任何平台与模型。只要上下文、测试用例和业务资产留在自己的服务器里,底层底座怎么洗牌,企业的经验资产永远不会灰飞烟灭。”

                  何万青最后补充道,资产不仅要属于组织,更要反哺个人:“员工投入心血积累的经验,不该变成死锁在某个封闭平台里的黑盒。好的产品必须让这些经验既能沉淀为组织资产,也能让每个参与建设的员工随时提取、理解和复用,这才是长久的共赢。”

                  全面开源:数字 AI 员工,先有数字方法论

                  发布会尾声,SoduWork 技术 VP 叶丽文向与会嘉宾与全球直播间的开发者隆重介绍了项目核心团队。这支由来自清华大学、北京大学等顶尖高校背景专家领衔的团队,历经 3000 多次代码提交、70 多个版本迭代与 1800 多个自动化测试的严苛打磨,最终向全球开发者交出了这份诚意之作。

                  从最初的技术探索到如今正式开源,SoduWork 得到了来自学术界、工业界众多技术专家、个人开发者以及社区伙伴的积极响应。他们参与架构探讨、提交首批反馈、打磨测试用例,不仅是 SoduWork 的首批使用者,更是推动项目持续创新与发展的重要力量。

                  为了感谢这些与项目并肩同行的开拓者,发布会现场特别设立了 「SoduWork 首批开源先锋」荣誉授予仪式。多位支持项目、深度参与共建的开发者先锋代表受邀登台,共同见证这一属于开源共建者的荣耀时刻。

                  这一仪式的设立,标志着 SoduWork 正式从“实验室打磨”迈入“全球社区共建”的新阶段。未来,团队将设立更加开放的社区贡献机制、开发者支持计划与插件生态激励,让每一位开发者的经验都能在这里被看见、被复用。

                  正如 SoduWork 开源仓库首页的那句宣言:

                  “数字 AI 员工,先有数字方法论。”

                  方法留下了,底座如何更替都不足为惧。随着 SoduWork 的正式开源,一个让个人经验真正涌现为组织智能、让人机协作具备确定性与治理闭环的全新时代,正在拉开序幕。


                  目前,SoduWork 已在 GitHub 全面开源。开发者与企业用户可通过以下地址获取源码、Docker 部署指南及完整文档,即刻体验本地极速启动:
                  项目主页:https://github.com/mdiri-ai/SoduWork

                  阅读原文

                  跳转微信打开

                  怒批Linux内核是“人类垃圾代码”!遭网友「围攻」后,GrapheneOS删帖澄清:我们不是这个意思

                  2026年11月17日 15:11

                  CSDN 2026-11-17 15:11 江苏

                  一个自己也依赖 Linux 内核的项目,凭什么把话说得这么绝?

                  整理 | 郑丽媛

                  出品 | CSDN(ID:CSDNnews)

                  AI 写代码已经够有争议了,没想到这次连 Linux 内核都被拉出来“挨骂”了。

                  近日,主打隐私和安全的移动操作系统 GrapheneOS 团队在社交平台 X 上与网友展开了一场激烈争论。面对“LLM 生成的代码质量差、没人能维护”的质疑,他们不仅坚称 AI 大模型正在显著提升项目代码质量,还直接把矛头指向了 Linux 内核,称其数百万行代码是 “human slop”(人类制造的垃圾代码)。

                  更狠的是,GrapheneOS 认为,Linux 从诞生之初就选择了一条背离稳健软件架构的发展路线:单体内核、缺乏内部隔离、大量内存不安全代码,甚至一个冷门驱动中的小错误,都可能演变成高权限代码执行漏洞。

                  这番言论很快引发了开发者社区的围观。有人赞同它对 Linux 安全问题的批评,也有人反过来质疑:一个自己也依赖 Linux 内核的项目,凭什么把话说得这么绝?

                  网友劝 GrapheneOS 别用 AI,开发团队:恰恰相反!

                  事情最初,来自一位 X 网友 Bilskirnir3124 对 GrapheneOS 使用 LLM 的不满。

                  他认为,LLM 生成的代码会让产品质量变差,团队成员也可能逐渐失去对代码库的理解。一旦 AI 生成的代码越来越多,最后可能连开发者自己都不知道系统是怎么运行的。

                  “GrapheneOS 本来是一个很棒的项目,我不想看到它被 LLM 代码毁掉。”

                  GrapheneOS 团队显然不接受这个判断。他们表示,使用 LLM 进行代码审查和 Bug 排查后,项目代码质量已经有了明显提升。

                  例如,此前他们要把 Pixel 10 的驱动程序从 Linux 6.6(QPR1)和 Linux 6.12(QPR2)移植到 Linux 6.18,就借助 AI 提前发现了大部分潜在问题,所以那次移植工作异常顺利。

                  不仅如此,GrapheneOS 内置了面向用户的崩溃报告系统和日志查看器,用户可以直接向团队提交系统运行中出现的问题:过去,开发者虽然能收到大量崩溃堆栈和日志,却不一定能快速定位问题根源;现在,大模型可以帮助团队分析这些信息,更快找出 Bug 出现的位置和原因。

                  GrapheneOS 特别强调,自己并不是在搞所谓的“氛围编程(Vibe Coding)”,不会让 AI 随便生成一段代码,就直接部署到服务器或交付给用户。

                  他们目前主要把 AI 用在代码审查、Bug 定位和问题修复上,甚至因为最近的工作重点是清理 Bug、减少系统冗余开销,团队已经有一段时间没有推出太多新的操作系统功能了。

                  大骂 Linux 内核是“人类垃圾代码”

                  真正让这场讨论火起来的,是 GrapheneOS 随后的一番言论。面对网友关于 AI 代码是否会让团队失去理解能力的质疑,GrapheneOS 团队回应称:

                  “我们现在对代码的理解比以前深入得多。要知道,我们并没有编写其中绝大多数代码,而且我们的质量标准远高于 Google。如今,我们终于有了能帮助自己理解和处理数百万行‘人类垃圾代码’(human slop)的工具,比如 Linux 内核。”

                  不得不说,这里的“human slop”相当刺耳。Slop 原本有劣质内容、糟粕的意思,近年来也经常被用来形容低质量的 AI 生成内容。

                  而 GrapheneOS 把它用来形容 Linux 内核,相当于直接把矛头指向了人类开发者几十年来积累的软件代码。网友 Bilskirnir3124 都忍不住吐槽:“human slop?哥们,你这用词可真够狠的。”

                  但 GrapheneOS 并没有收敛,反而继续解释:不能把大型软件、固件和硬件项目长期存在的安全问题都归咎于 LLM。像 Linux,每个月都有大量早已存在的严重 Bug 被发现和修复,即使没有 AI,Linux 也早就充斥着大量人类开发者粗制滥造的代码。

                  因此在 GrapheneOS 看来,AI 确实可能让项目更快地产出垃圾代码,但这并不是 AI 带来的新问题,而是整个软件行业早已存在的现状。真正应该关注的变化是:有了大模型,现在能更轻松地发现这些问题,从而倒逼整个行业改进软件工程实践。

                  不只停留在代码质量上,紧接着 GrapheneOS 又把批评进一步指向了 Linux 的底层设计:“Linux 从诞生之初就选择了一条背离稳健软件架构的发展路线。”

                  根据 GrapheneOS 的说法,Linux 的主要问题集中在三个方面:

                  ●单体内核架构:大量核心功能和驱动运行在内核空间,内部隔离能力有限。

                  ●内存安全问题:Linux 内核大量使用 C 语言编写,容易出现越界访问、释放后使用等内存错误。

                  ●漏洞影响范围大:即使是一个很少使用的冷门驱动出现错误,也可能让攻击者获得内核级权限。

                  简单来说,Linux 内核中的驱动通常拥有很高的系统权限。一旦出现可利用的内存安全漏洞,攻击者就可能借此实现本地权限提升,甚至进一步控制系统。

                  当然,单体内核并不意味着完全没有隔离机制,Linux 也一直在通过 SELinux、内核配置裁剪等方式缩小攻击面。但 GrapheneOS 的核心不满在于:这些安全措施还是无法从根本上消除内核内部代码相互影响带来的风险。

                  自己也用 Linux,却说它不够安全?GrapheneOS 其实早就想换掉它

                  这番批评很快引来了一个相当尴尬的问题:既然 Linux 内核这么不靠谱,那GrapheneOS 你自己为什么还在用?要知道,GrapheneOS 是基于 Android 开源项目(AOSP)开发的,而 Android 的底层基础正是 Linux 内核。

                  对此,GrapheneOS也承认,目前继续用 Linux 的一个重要原因,就是还没有找到足够成熟的替代方案。其实,GrapheneOS 官方 FAQ 中已明确提到了长期路线图:项目未来希望摆脱对 Linux 内核的依赖,转向基于微内核(Microkernel)的系统架构,同时提供 Linux 兼容层。

                  与 Linux 的单体内核不同,微内核会尽可能将驱动、文件系统等服务移出核心内核,让它们在相对独立的环境中运行。这样一来,即使某个组件出现Bug,也更容易限制其影响范围。

                  不过,这条路并不好走。操作系统需要兼顾硬件驱动、应用兼容性、性能和安全性,想要完全替换 Linux,显然不是简单换一套代码就能完成的。因此,GrapheneOS 目前采取的还是渐进式路线:先通过硬件虚拟化、隔离机制和内核加固,逐步强化现有系统的安全边界。

                  争议闹大了!GrapheneOS 删除“human slop”帖子,紧急澄清

                  很快,GrapheneOS 怒批 Linux 是“人类垃圾代码”的这番言论在开源社区引起了不小的争议。

                  有网友直言,无论团队的技术观点是否正确,他们本质上就是一群喜欢故意挑衅、标新立异的人:“如果喜欢 GrapheneOS 这个项目,最好还是少看他们在 X、Mastodon 和 Hacker News 上发表的犀利言论,否则很容易被这种高高在上的语气给劝退。”

                  但也有人持相反意见,认为真正考虑在手机上使用 GrapheneOS 的人,反而应该关注开发团队的公开言论。毕竟,软件由什么样的人维护同样重要,如果维护者的行为和沟通方式存在问题,未来也可能给用户带来风险。

                  还有一条评论说得更加直接:“GrapheneOS 确实是一个非常出色的项目,但负责对外沟通的人,绝对是整个开源软件开发领域里最傲慢、最令人讨厌的混蛋之一。”

                  随着争议范围逐渐扩大,GrapheneOS 迅速把那条骂 Linux 是“human slop”的帖子给删了。

                  在最新回应中,GrapheneOS 称其原本想表达的观点遭到了曲解,自己的本意是想说明 GrapheneOS 当前所依赖的底层技术基础存在不少问题,但同时对未来的改进持乐观态度。

                  他们也再次强调,GrapheneOS 建立在一个规模庞大、结构复杂的单体内核之上,而这个内核主要使用 C 语言编写,存在大量安全漏洞。团队真正想表达的是:现有的软件基础设施还有很大的改进空间,开发者需要充分利用更强大的工具来解决这些问题。

                  至于此前那句颇具攻击性的“human slop”,GrapheneOS 也解释称,是在回应某位网友把使用 AI 的项目称为“AI slop”(AI 垃圾代码)时,带有调侃意味的一种反击而已。

                  不过,这番澄清并没有完全平息争议。毕竟,原先的措辞确实相当激烈,而且 GrapheneOS 对 Linux 内核架构的批评并没有撤回。删除一条帖子,也不等于此前的技术观点发生了改变。

                  那么,对于这件事你的看法又是什么呢?

                  参考链接:

                  https://www.reddit.com/r/linux/comments/1xxg2r0/grapheneos_calls_linux_a_human_slop_kernel_and/

                  https://x.com/GrapheneOS/status/2122074518437134627

                  图片

                  DeepSeek开源昇腾组件工程实践:算力利用率最高99.8%,从算子库走向超节点与云训推平台,4位华为专家现场拆解

                  ⏰ 11 月 21 日,2026 奇点智能技术大会特设「昇腾云训推平台算力开源生态实践专场」。

                  该专场将围绕 DeepSeek 开源昇腾基础组件、昇腾超节点、云训练 Infra、推理 PaaS、AI Coding 全栈加速等方向深度分享,完整呈现从芯片软件生态到云端训推平台的工程落地路径。

                  面向前 100 名报名用户免费开放,还可领取原价值 1500 元的大会专场议程,席位有限,先报先得!

                  图片

                  跳转微信打开

                  阿里巴巴:腰斩110896人。

                  2026年11月17日 14:12

                  小林coding 2026-11-17 14:12 北京

                  还记得年初阿里巴巴集团公布了财报,数据显示,截至25年12月31日,阿里的员工总数为128197人,而2021年12月31日,这一数字为259316人。这也意味着,过去5年阿里员工数减少了100000余人。但截止至当前,据26年9月30日的财报,现阿里员工已达到141721人。

                  阿里这一轮人员规模的“先出清、后定向扩招”,本质上是一次‌非核心业务向AI大模型赛道的结构性资源转移‌,所有动作都围绕全栈AI战略集中倾斜。

                  新增人员几乎全部流向AI相关板块:通义大模型研发、平头哥自研AI芯片、阿里云智算集群、千问办公事业部(Agent方向)。

                  2026年3月到9月的半年间,单半年增员超1万人,AI相关人才扩招速度明显加快。

                  阿里Agent赛道属于集团核心战略级扩招方向,薪资整体高于普通互联网开发岗,股票占比明显偏高:

                  • ‌应届生‌:普通本科年薪30-45万,985硕士SSP岗位总包可达60-100万,阿里星计划顶尖Offer最高突破120万。

                  • ‌1-3年经验工程师‌:月薪4.5-6.5万,年薪50-80万,掌握RAG、多Agent协作落地能力的人才薪资可溢价20%。

                  • ‌3-5年资深工程师‌:月薪6-9万,年薪80-120万,核心技术岗股票占比可达总包的30%以上。

                  • ‌专家/架构师级别‌:年薪150-200万+股票,负责核心Agent系统架构设计的顶尖人才总包可突破250万。

                  如果你想拿高工资、延迟职业寿命,就业市场已经给我们指明了方向,一定要往AI方向转,后端一定要有Agent项目经验!因为它是离钱最近、落地最快、需求最猛的就业方向!

                  打开各个招聘网站可以清晰的看到,几乎所有大厂都在招聘Agent相关人才,Agent相关岗位数量呈指数级增长,薪资更是比传统开发岗高出40%+,供需比高达1:8。

                  高薪,是agent、AI大模型领域缺人的事实依据,但是找不到工作的大有人在,也是事实。

                  问题就在,申请agent开发、大模型岗的人很多,但实际能够胜任国内Agent开发岗技术要求的人却很少。求职者所具备的能力根本无法匹配一线企业核心岗位的需求。

                  为了帮大家解决以上问题,真正成长为具备面试国内一线agent开发、大模型岗位的能力要求的人才,我们打造了一个《就业保薪班》,确保你学习完以后,能够具备在实际工作当中解决实际问题的能力,成为一名合格的agent大模型工程师。

                  (以上岗位技术要求,课程中全部涉及)

                  并且该班级承诺:

                  在校应届生就业薪资拿不到30W

                  在职人员最低薪资涨幅低于40%-50%,均可以全额退款。

                  目前已经有上千位同学通过该计划拿到offer了,平均薪资达到38w+,最新一期学员就业薪资最高能拿到85K!

                  扫码添加顾问,备注 “咨询课程”

                  🎁 距离上岸,也许只差这一次助攻

                  核心内容

                  为了学生能够学习到真正在企业拿来即用的技术,我们高薪聘请20位一线大厂顶级专家成立教研团队,历时两年时间,打磨出超精品的AI课程,帮助学员掌握基础理论以及实战项目,满足行业内绝大多数岗位需求,打造行业内TOP级算法工程师人才!

                   课程重点围绕主流热门行业商业项目实战展开,在企业级项目中,把理论和实践   相结合,帮助学员用最短的时间进入AI领域并掌握相关知识,快速上手主流深度   学习开发框架,具备人工智能工业项目动手能力。

                  AI实战项目

                  以上项目是一套通用的解决方案,可以从中整理出面向不同业务的相似实现,适合大型互联网、自动驾驶、工业缺陷检测、文本生成、语言模型、医疗、农业等等不同的应用场景,在整个授课过程中,老师更加注重是业务与思想的传播,让你轻松应对工作中的问题并且有举一反三的能力。

                  由于篇幅有限,就不在这里赘述,如果想进一步了解,定制属于自己的提升计划。

                  请扫码添加课程顾问,备注“咨询课程”

                  1v1定制学习计划

                  学员学习成效,真实案例展示

                  跟你同步下上一期【AI就业保薪特训营】的就业成果!96.9%的学员都顺利拿下国内外名企AI、算法岗位,其中最高月薪做到了75K!
                  接下来展示一部分学员的就业情况,我们承诺,所有信息都是真实可核实的,为保护隐私就不展示姓名了。如果想查看更多学员案例,随时找我哈。

                  【1】王同学,4年Java开发转型算法岗,本科学历,年薪从25w涨到42w,涨幅68%。选择系统学习的好处有,老师带领着学习项目知识,售后老师服务热情,还有大厂内推机会,更容易拿高薪。

                  【2】谢同学,报名前做后端开发5年,工作上遇到了瓶颈,薪资也涨不上去,调研了一番后决定学习算法,通过4个月的学习,现在成功转型图像算法岗位,还涨薪至48k,年薪达到72w。

                  【3】刘同学,作为一名应届生,一毕业就成功拿下百度大模型算法岗offer,年薪高达48W,真正赢在了AI时代的起跑线上~

                  【4】曹同学,成功拿下AI算法岗•综合年薪50w。曹同学是本科电子信息专业,转型前做了4年运维工作。因为薪资不高、发展受限,加上对AI技术很感兴趣,选择转型AI方向,在就业老师的内推帮助下,成功拿到了50w的offer。

                  【5】车同学,成功被内推到腾讯的NLP算法岗,薪资从13.5k跃升到27k*16薪,年薪翻了将近3倍。

                  另外,我们有往期学员通过我们的专属内推通道,已高效入职多家头部大厂。我们深知,教育的核心是交付结果,只有帮学员扎实掌握技术、顺利拿到理想offer,才能收获真实的口碑与信任。口碑是我们最看重的名片,因此我们对每一位学员的学习与就业全程负责,不做任何无效交付。

                  分期服务及就业保障

                  该课程可以为你提供3、6、12期分期付款,入学0压力。

                  报名立马签订保涨薪就业协议,对结果负责。

                  在职程序员承诺最低涨幅40%-50%。

                  在校应届生承诺最低年薪30万。

                  若课程结束后,拿不到合同签订的offer或者offer就业薪资达不到年薪30万,即立马退还全部学费,且保留赠送的所有资源,绝对不会让你吃亏!

                  • 我们再次郑重承诺:所有保障条款白纸黑字写入协议,双方签字盖章,具备完全法律效力!不搞任何文字套路,不玩半点模糊猫腻!先免费咨询、免费了解,合适再学,不合适也绝不纠缠!多懂一门AI新技能,多踩准一个行业新赛道,下一个靠技术逆袭上岸的,说不定就是你!

                  扫码添加课程顾问,备注 “咨询课程”

                  ✨ 不花钱,也能先体验大厂AI课

                  🎁 扫码直接领【AI基础资料包+免费试听课】,不花一分钱,先摸清行业方向

                  跳转微信打开

                  ❌