GitHub 把 Copilot 变成了“AI 中控台”:一场关于开发者身份的豪赌

2026年10月30日 | 来源:Dev.to
GitHub Copilot 多智能体 AI编程
当 GitHub Universe 的灯光亮起,人们意识到:Copilot 不再只是那个帮你补全代码的“副驾驶”了。它正在变成一个调度多个 AI 智能体的工作台——开发者第一次以“指挥官”而非“打字员”的身份登上了舞台。

一、从“副驾驶”到“多智能体工作区”:Copilot 的三次进化

Infographic cover

回顾 Copilot 的进化路径,你会看到一个清晰的三段式曲线:

第一阶段(2021-2023):代码补全工具。 核心场景是行内补全,本质是“更聪明的自动完成”。开发者对它的态度是“有它挺好,没它也能活”。 第二阶段(2023-2024):Chat 对话助手。 Copilot Chat 的加入让它从被动补全走向主动对话,开发者开始用自然语言描述需求、生成测试、解释遗留代码。 第三阶段(2024 至今):多智能体工作台。 这是本次 GitHub Universe 发布的核心——GitHub 官方的表述是,重新设计的 Copilot 定位为连接多个 AI 智能体的开发工作台,其中最引人注目的就是全新的 Copilot Projects 功能。

这意味着什么?意味着 Copilot 正在从“单个助手”进化为“智能体编排平台”。你不再是和一个 AI 对话,而是在指挥一支 AI 团队。

Key figures

二、Projects 功能:把“任务”变成智能体的调度单元

根据 Dev.to 的报道,新特性将 Copilot 重构为一个多智能体工作区。虽然 GitHub 官方披露的细节仍在陆续放出,但从架构思路上看,其核心逻辑可以概括为:

1. 项目级上下文:智能体不再只看到你当前打开的文件,而是理解整个项目的结构、依赖和历史

2. 任务拆解与分发:开发者提出的目标会被拆解为多个子任务,由不同的智能体并行处理

3. 结果汇总与校验:多个智能体的产出汇聚到统一界面,由开发者审核合并

用一张图来理解这个架构:

开发者 提出目标 · 审核结果 Copilot Projects 工作台 任务拆解 ↓ 结果汇总 ↑ 编码智能体 实现功能 · 修复 Bug 测试智能体 生成用例 · 覆盖率检查 审查智能体 代码审查 · 安全扫描

这个架构本质上借鉴了业界已经验证的 Multi-Agent Orchestration 模式。我们可以用一段伪代码来描述这种编排思想:

IMPACT checklist

# 多智能体编排示意(伪代码)
class CopilotProject:
    def __init__(self, goal: str, repo: Repo):
        self.goal = goal          # 开发者的高层目标
        self.repo = repo          # 项目级上下文
        self.agents = load_agents(["coder", "tester", "reviewer"])

    def run(self):
        # 1. 任务拆解:把目标变成可分发的子任务
        tasks = self.plan(self.goal, context=self.repo.context())

        # 2. 并行分发:各智能体独立执行
        results = {}
        for agent, task in zip(self.agents, tasks):
            results[agent.name] = agent.execute(
                task, 
                context=self.repo.context(),
                shared_state=self.shared_state  # 智能体间共享状态
            )

        # 3. 汇总校验:人类做最终裁决
        return self.aggregate(results, reviewer="human")

注意最后一步:reviewer="human"。这不是炫技,而是目前所有智能体产品都无法绕过的红线——人类必须在关键决策点签字。

三、为什么 GitHub 是做这件事的最佳人选?

市面上做多智能体编排的工具并不少:LangGraph、CrewAI、AutoGen 都在开发者社区有相当声量。但 GitHub 做这件事有别人不具备的独特优势:

第一,坐拥代码世界的“操作系统”地位。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI——这些动作的原生载体就是 GitHub。GitHub 不需要“接入”开发流程,它本身就是流程。 第二,数据护城河。 智能体要理解项目上下文,需要的是 issue 历史、PR 讨论记录、Code Review 评论——这些语义信息大量沉淀在 GitHub 平台内,第三方工具很难完整获取。 第三,商业闭环现成。 Copilot 已经完成了订阅付费模式的验证,多智能体能力可以直接叠加到现有订阅体系上,商业化路径清晰。

四、冷静看待:多智能体≠自动解决一切

作为长期观察这个行业的媒体,我们想泼一点冷水:

1. 智能体协作的可靠性仍是未解难题。 多个智能体并行工作,意味着错误也会被“并行放大”。一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,最后由审查智能体“放行”。级联错误(error cascading)的治理,比单智能体时代更难。 2. 成本问题不容忽视。 多智能体意味着多倍 token 消耗。一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上。GitHub 的订阅定价能否覆盖这个成本结构,还需观察。 3. 开发者角色的真正转变才刚开始。 “指挥官”听起来很酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。Prompt Engineering 之后,行业可能需要新的技能:"Agent Engineering"——如何精确描述任务、如何设计验收标准、如何在多个智能体的产出之间做仲裁。

五、写在最后:开发者的下一个十年

GitHub Universe 上的这次发布,与其说是产品更新,不如说是一次宣言:软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”。

这个判断的方向大概率是对的,但节奏可能比发布会 PPT 上呈现的要慢。对于开发者而言,最务实的态度是:拥抱工具演进,但守住自己的核心竞争力——架构判断力、业务理解力、以及那个“最终签字的人”的审慎。

工具越强大,使用工具的人的判断力就越值钱。


信息源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh);GitHub Universe 官方发布信息 查看原文 ↗
推广
🚀 想亲手把文中的 AI 项目跑起来?
阿里云轻量应用服务器,开箱即用,新用户专享优惠——半小时从零部署一台自己的 AI 工作机。
去了解 →

📋 多平台草稿预览 (12平台差异化改编)

GitHub 把 Copilot 变成 AI 中控台:1 亿开发者的身份,被重新定义了

Copilot 不再帮你打代码了。GitHub Universe 灯光亮起那一刻,它成了调度多个 AI 智能体的工作台——而你,第一次以“指挥官”而非“打字员”的身份登上舞台。

配图

这句话不是营销话术。本次发布的核心功能 Copilot Projects,正在把软件开发的生产单元,从“人+工具”改写成“人+智能体团队”。但热闹背后,一次任务的 token 消耗可能是单次 Chat 的十倍以上——这更像一场豪赌。

一、Copilot 的三次进化:从“没它也能活”到“离不开”

回看 Copilot 这四年,是一条清晰的三段式曲线。

第一阶段(2021-2023):代码补全工具。 核心场景是行内补全,本质是“更聪明的自动完成”。开发者对它的态度是“有它挺好,没它也能活”——它只是加快了打字速度,没有改变工作方式。 第二阶段(2023-2024):Chat 对话助手。 Copilot Chat 的加入让它从被动补全走向主动对话。你开始用自然语言描述需求、生成测试、解释遗留代码。它从“帮你打字”变成了“跟你讨论”。 第三阶段(2024 至今):多智能体工作台。 这是本次 GitHub Universe 发布的核心。GitHub 官方的表述是:重新设计的 Copilot 定位为连接多个 AI 智能体的开发工作台,其中最引人注目的就是全新的 Copilot Projects。

这意味着什么?意味着 Copilot 正在从“单个助手”进化为“智能体编排平台”。你不再是和一个 AI 对话,而是在指挥一支 AI 团队。

【配图建议:Copilot 三阶段进化时间轴示意图,从代码补全到 Chat 再到多智能体工作台】

二、Copilot Projects:把任务变成智能体的调度单元

根据 Dev.to 的报道,新特性将 Copilot 重构为一个多智能体工作区。官方细节仍在陆续放出,但从架构思路上看,核心逻辑是三步:

1. 项目级上下文。 智能体不再只看到你当前打开的文件,而是理解整个项目的结构、依赖和历史。这一步很关键——脱离项目上下文的 AI 代码,往往看着对、跑起来崩。 2. 任务拆解与分发。 开发者提出的目标会被拆解为多个子任务,由不同的智能体并行处理。示例架构里有三类角色:编码智能体负责实现功能、修复 Bug;测试智能体负责生成用例、做覆盖率检查;审查智能体负责代码审查、安全扫描。 3. 结果汇总与校验。 多个智能体的产出汇聚到统一界面,由开发者审核合并。

这个编排流程的终点,是那句 reviewer="human"——人类必须在关键决策点签字。这不是炫技,而是目前所有智能体产品都无法绕过的红线。

三、为什么是 GitHub?三个别人拿不走的优势

配图

市面上做多智能体编排的工具并不少:LangGraph、CrewAI、AutoGen 都在开发者社区有相当声量。但 GitHub 做这件事,有三个别人不具备的独特优势。

第一,坐拥代码世界的“操作系统”地位。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI——这些动作的原生载体就是 GitHub。GitHub 不需要“接入”开发流程,它本身就是流程。第三方工具再强,也得先解决“住在哪”的问题。 第二,数据护城河。 智能体要理解项目上下文,需要的是 issue 历史、PR 讨论记录、Code Review 评论——这些语义信息大量沉淀在 GitHub 平台内,第三方工具很难完整获取。谁的上下文更完整,谁的智能体判断就更准。 第三,商业闭环现成。 Copilot 已经完成了订阅付费模式的验证,多智能体能力可以直接叠加到现有订阅体系上,商业化路径清晰。对比还在摸索收费模式的编排框架,这是降维打击。

四、泼三盆冷水:多智能体 ≠ 自动解决一切

发布会很燃,但有三件事必须说清楚。

1. 级联错误,比单智能体时代更难治。 多个智能体并行工作,意味着错误也会被“并行放大”。一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,最后由审查智能体“放行”——三个 AI 集体给你盖了个错误的章。这种级联错误(error cascading)的治理,是行业未解难题。 2. 成本结构尚未验证。 多智能体意味着多倍 token 消耗。一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上。GitHub 的订阅定价能否覆盖这个成本结构,还需观察。十倍不是形容词,是实打实的账单。 3. 开发者的新功课才刚开始。 “指挥官”听起来很酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。Prompt Engineering 之后,行业可能需要新的技能:"Agent Engineering"——如何精确描述任务、如何设计验收标准、如何在多个智能体的产出之间做仲裁。

【配图建议:开发者坐在多块屏幕前审核多个智能体产出合并界面的场景图】

五、写在最后:下一个十年,判断力比手速值钱

GitHub Universe 上的这次发布,与其说是产品更新,不如说是一次宣言:软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”。

这个判断的方向大概率是对的,但节奏可能比发布会 PPT 上呈现的要慢。对开发者而言,最务实的态度是:拥抱工具演进,但守住自己的核心竞争力——架构判断力、业务理解力,以及那个“最终签字的人”的审慎。

工具越强大,使用工具的人的判断力就越值钱。

互动提问: 如果明天 Copilot Projects 摆在你面前,你愿意把第一个任务交给 AI 团队吗?评论区聊聊你最放心/最不放心的环节。 配图

信息源:Dev.to

标签:GitHub, Copilot, 多智能体, AI编程


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

【视频脚本总览】总时长 60 秒 | 竖屏 9:16 | 口播快节奏,前 3 秒语速稍快制造冲击,中段放缓讲清逻辑,结尾抛问时停半拍

【分镜 1|0-3秒|黄金钩子】

画面:GitHub Copilot 界面特写,光标快速跳出多行补全代码,画面突然定格

口播:帮你补全代码的 Copilot,刚把自己升级成了能指挥一群 AI 的总指挥台!

字幕:Copilot 变身「AI 中控台」!

【分镜 2|3-15秒|事件铺开】

画面:GitHub Universe 大会现场画面切换到新功能「Projects」界面演示

口播:GitHub Universe 大会上,GitHub 发布了 Copilot 新功能,叫 Projects。注意,这不是小更新。Copilot 以前只是个副驾驶,你打字,它补全。现在,它是一个能同时调度多个 AI 智能体的工作台。来源是 Dev.to 的报道,加上 GitHub 官方发布信息,不是小道消息。

字幕:新功能 Projects = 多智能体工作台

【分镜 3|15-32秒|核心冲突】

画面:左边程序员疯狂敲键盘,右边一个人点点鼠标、多个 AI 窗口同时跑任务,分屏对比

口播:这场更新真正动的,是你的身份。以前开发者的价值,是把想法一个字一个字敲进编辑器,你是打字员。以后呢?你是指挥官。你不亲手写,你调度一堆 AI 智能体替你写。谁赢?会用 AI 编排任务的人。谁危险?只会闷头敲代码的人。

字幕:打字员 → 指挥官

【分镜 4|32-45秒|数据实证】

画面:Copilot 从「单个补全框」到「多个智能体面板」的界面演变动效演示

口播:看清楚这个变化的跨度。第一阶段,Copilot 帮你补一行代码。第二阶段,它聊天、改 bug。现在第三阶段,GitHub 直接把它做成中控台,你在一个界面里派活给多个智能体,让它们分工干活。这不是加功能,这是把 Copilot 的定位整个换掉了。

字幕:补全工具 → 智能体调度中心

【分镜 5|45-55秒|反直觉升华】

画面:一个人坐在多块屏幕前喝咖啡,屏幕上多个 AI 任务并行完成

口播:反直觉的地方在这:写代码这个职业可能没消失,但“打字”那部分价值,正在被抽走。GitHub 在赌一件事——未来开发者最值钱的能力,不是敲得快,而是指挥得准。这赌注,押的就是你我的职业身份。

字幕:值钱的不再是敲代码,是指挥 AI

【分镜 6|55-60秒|互动CTA】

画面:出镜人对镜头,字幕弹出评论问题

口播:你愿意当打字员还是指挥官?评论区聊聊。关注我,AI 工具每次大更新,我第一时间拆给你看。

字幕:打字员还是指挥官?评论区见

【BGM与节奏】

情绪:科技感、略带悬念的电子节拍;0-3秒鼓点重击对应钩子;15秒处节奏转沉稳;45秒起音乐渐弱突出人声;55秒收尾一个上扬音效配 CTA 弹字幕。音效:代码键盘声(分镜1)、“叮”提示音(字幕弹出时)。

【素材清单】

分镜1:Copilot 代码补全界面录屏(实拍/录屏素材)

分镜2:GitHub Universe 大会画面 + Projects 功能界面截图(录屏素材)

分镜3:分屏对比动画(敲键盘实拍 + 多窗口演示录屏)

分镜4:Copilot 界面演变动效(截图 + 动画包装)

分镜5:多屏幕工作场景实拍/图库素材

分镜6:真人出镜口播(主画面)


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

GitHub 把 Copilot 变成了“AI 中控台”:一场关于开发者身份的豪赌 🔥

当 GitHub Universe 的灯光亮起,人们意识到:Copilot 不再只是那个帮你补全代码的“副驾驶”了。它正在变成一个调度多个 AI 智能体的工作台——开发者第一次以“指挥官”而非“打字员”的身份登上了舞台。


当 GitHub Universe 的灯光亮起,人们意识到:Copilot 不再只是那个帮你补全代码的“副驾驶”了。它正在变成一个调度多个 AI 智能体的工作台——开发者第一次以“指挥官”而非“打字员”的身份登上了舞台。

一、从“副驾驶”到“多智能体工作区”:Copilot 的三次进化

回顾 Copilot 的进化路径,你会看到一个清晰的三段式曲线:


📌 来源:Dev.to

#GitHub #Copilot #多智能体 #AI编程

#科技资讯 #彩虹洋葱AI


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

如何看待 GitHub 将 Copilot 重构为“多智能体工作台”?这是产品更新,还是重新定义开发者?

先说结论:这不是又一个功能更新,而是 GitHub 在重新定义“开发者”这个词——从写代码的人,变成给 AI 团队签字的人。

配图

一、看清楚这次发布到底是什么

Copilot 的进化路径是一条清晰的三段式曲线:2021 到 2023 年,它是代码补全工具,本质是“更聪明的自动完成”,开发者对它的态度是“有它挺好,没它也能活”;2023 到 2024 年,Copilot Chat 让它从被动补全走向主动对话;2024 至今,也就是本次 GitHub Universe 发布的核心——官方将其重新定位为连接多个 AI 智能体的开发工作台。

前两次是迭代,这一次是质变。你不再是和一个 AI 对话,而是在指挥一支 AI 团队。

承载这个转变的,是全新的 Copilot Projects 功能。根据 Dev.to 的报道,它的架构逻辑可以概括为三步:

1. 项目级上下文:智能体不再只看你当前打开的文件,而是理解整个项目的结构、依赖和历史;

2. 任务拆解与并行分发:开发者提出的目标被拆成多个子任务,由不同智能体并行处理;

3. 结果汇总与校验:多个智能体的产出汇聚到统一界面,由开发者审核合并。

原文用一段伪代码把这套编排思想讲得很透,值得贴出来细看:

class CopilotProject:
    def __init__(self, goal: str, repo: Repo):
        self.goal = goal          # 开发者的高层目标
        self.repo = repo          # 项目级上下文
        self.agents = load_agents(["coder", "tester", "reviewer"])

    def run(self):
        # 1. 任务拆解:把目标变成可分发的子任务
        tasks = self.plan(self.goal, context=self.repo.context())

        # 2. 并行分发:各智能体独立执行
        results = {}
        for agent, task in zip(self.agents, tasks):
            results[agent.name] = agent.execute(
                task, 
                context=self.repo.context(),
                shared_state=self.shared_state  # 智能体间共享状态
            )

        # 3. 汇总校验:人类做最终裁决
        return self.aggregate(results, reviewer="human")

【配图建议:开发者—Copilot Projects 工作台—编码/测试/审查三类智能体的分层架构图】

注意最后那行 reviewer="human"。这不是炫技,而是 GitHub 自己都承认:这支 AI 团队的最终裁决权,暂时不敢交给 AI。所有智能体产品都绕不过这条红线——人类必须在关键决策点签字。

二、为什么是 GitHub,而不是 LangGraph 们?

做多智能体编排的工具不少:LangGraph、CrewAI、AutoGen 在开发者社区都有相当声量。但 GitHub 做这件事有别人不具备的三重优势。

第一,平台即流程。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI——这些动作的原生载体就是 GitHub。第三方工具需要“接入”开发流程,而 GitHub 本身就是流程。 第二,数据护城河。 智能体要理解项目上下文,靠的是 issue 历史、PR 讨论记录、Code Review 评论。这些语义信息大量沉淀在 GitHub 平台内,LangGraph、CrewAI、AutoGen 都不是代码托管平台,很难完整获取。 第三,商业闭环现成。 Copilot 已经完成了订阅付费模式的验证,多智能体能力可以直接叠加到现有订阅体系上。

用一句话概括:LangGraph 们玩了两年多智能体编排,最后被一个坐拥 1 亿开发者的代码托管平台降维进场了。

三、泼点冷水:多智能体不等于更可靠

这是我最想强调的反直觉点。

多个智能体并行工作,意味着错误也会被“并行放大”。一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,最后由审查智能体“放行”——级联错误的治理,比单智能体时代更难,而不是更容易。

成本同样是问题。多智能体意味着多倍 token 消耗,一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上。GitHub 的订阅定价能否覆盖这个成本结构,还需要观察。

四、我的判断:方向对,节奏慢

“指挥官”听起来很酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。软件开发的生产单元正在从“人+工具”变成“人+智能体团队”,这个方向大概率是对的,但节奏会比发布会 PPT 呈现的慢。

对开发者而言,Prompt Engineering 之后,下一个技能分水岭可能是原文提出的 "Agent Engineering"——如何精确描述任务、如何设计验收标准、如何在多个智能体的产出之间做仲裁。而架构判断力、业务理解力、以及“最终签字的人”的审慎,才是工具越强大时越值钱的东西。

留一个开放问题:当 AI 团队的产出需要验收时,验收标准该由人写,还是由另一个智能体验证?如果是后者,这条信任链的起点又该由谁签字?


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

GitHub 官宣:Copilot 变身“AI 中控台”,超 1 亿开发者的工作方式要变了

超过 1 亿开发者在用的 GitHub,刚刚在 GitHub Universe 大会上做了一个大动作:把 Copilot 从“帮你补全代码的副驾驶”,重新定位为连接多个 AI 智能体的开发工作台。这次发布最核心的新功能叫 Copilot Projects。一句话概括变化:开发者不再是“打字员”,而是第一次以“指挥官”的身份,指挥一支 AI 团队干活。

配图

【配图建议:GitHub Universe 发布会现场,Copilot 新版界面演示画面】

三次进化:Copilot 这四年走了三步

要理解这次发布有多大,得先看 Copilot 的进化路线:

第一阶段(2021-2023),它是代码补全工具,核心场景是行内补全,本质是“更聪明的自动完成”。开发者对它的态度是“有它挺好,没它也能活”。 第二阶段(2023-2024),Copilot Chat 加入,从被动补全走向主动对话。开发者开始用自然语言描述需求、生成测试、解释遗留代码——AI 第一次“主动”参与了。 第三阶段(2024 至今),也就是本次 GitHub Universe 发布的核心:Copilot 变成多智能体工作台。你不再和一个 AI 对话,而是在调度一支 AI 团队。

Copilot Projects 怎么干活?三步走

根据 Dev.to 的报道,Copilot Projects 的核心逻辑可以拆成三步:

1. 项目级上下文:智能体不再只看你当前打开的文件,而是理解整个项目的结构、依赖和历史。

2. 任务拆解与分发:开发者提出的目标会被拆成多个子任务,由不同智能体并行处理——编码智能体实现功能、修 Bug,测试智能体生成用例、查覆盖率,审查智能体做代码审查和安全扫描。

3. 结果汇总与校验:多个智能体的产出汇聚到统一界面,由开发者审核合并。

原文用了一段伪代码描述这套编排思想,最关键的是最后那行参数:

# 多智能体编排示意(伪代码)
class CopilotProject:
    def __init__(self, goal: str, repo: Repo):
        self.goal = goal          # 开发者的高层目标
        self.repo = repo          # 项目级上下文
        self.agents = load_agents(["coder", "tester", "reviewer"])

    def run(self):
        # 1. 任务拆解:把目标变成可分发的子任务
        tasks = self.plan(self.goal, context=self.repo.context())

        # 2. 并行分发:各智能体独立执行
        results = {}
        for agent, task in zip(self.agents, tasks):
            results[agent.name] = agent.execute(
                task, 
                context=self.repo.context(),
                shared_state=self.shared_state  # 智能体间共享状态
            )

        # 3. 汇总校验:人类做最终裁决
        return self.aggregate(results, reviewer="human")

配图 reviewer="human"——这不是炫技,而是目前所有智能体产品都绕不过的红线:人类必须在关键决策点签字。

【配图建议:开发者、Copilot Projects 工作台与三类智能体的架构流程图】

为什么是 GitHub 来做这件事?

市面上做多智能体编排的工具不少:LangGraph、CrewAI、AutoGen 在开发者社区都有相当声量。但 GitHub 有三个别人不具备的优势:

第一,坐拥代码世界的“操作系统”地位。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI——这些动作的原生载体就是 GitHub。它不需要“接入”开发流程,它本身就是流程。 第二,数据护城河。 智能体理解项目上下文,靠的是 issue 历史、PR 讨论记录、Code Review 评论。这些语义信息大量沉淀在 GitHub 平台内,第三方工具很难完整获取。 第三,商业闭环现成。 Copilot 已经验证了订阅付费模式,多智能体能力可以直接叠加到现有订阅体系上。至于新定价——官方尚未披露,这点必须说清楚。

三盆冷水:先泼醒再说好话

冷静看,这次豪赌有三个绕不开的坑:

其一,级联错误比单智能体时代更难治理。 多个智能体并行工作,错误也会被“并行放大”:一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,最后由审查智能体“放行”。 其二,成本不容忽视。 多智能体意味着多倍 token 消耗。一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上。订阅定价能否覆盖这个成本结构,还需观察。 其三,“指挥官”没那么好当。 指挥一支不可靠的 AI 团队,可能比亲自写代码更累。Prompt Engineering 之后,行业可能需要新技能——"Agent Engineering":如何精确描述任务、设计验收标准、在多个智能体的产出之间做仲裁。

写在最后

这次发布与其说是产品更新,不如说是一次宣言:软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”。方向大概率是对的,但节奏可能比发布会 PPT 上呈现的慢。

最务实的态度是:拥抱工具演进,但守住架构判断力、业务理解力,以及那个“最终签字的人”的审慎。工具越强大,使用工具的人的判断力就越值钱。

如果 Copilot Projects 明天就对你开放,你敢把多少核心代码交给一支 AI 团队去写?评论区聊聊。

来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

Copilot 不当副驾驶了。GitHub Universe 大会上,官方把它升级成“连接多个 AI 智能体的开发工作台”,新功能叫 Copilot Projects。

逻辑很简单:你提出目标,它拆成子任务,分给编码、测试、审查等多个智能体并行干活,结果汇总后由你审核合并。超过 1 亿开发者的角色,第一次从“打字员”变“指挥官”。

但要泼冷水:多智能体并行意味着错误也被并行放大,一次任务的 token 消耗可能是单次 Chat 的十倍以上。

你以为指挥 AI 团队更轻松?指挥一支会犯错的队伍,可能比亲自写代码更累。你愿意把整块功能交给 AI 团队跑,自己只做最终签字的人吗?

#GitHub# #Copilot# #AI编程#


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

【视频脚本总览】总时长 100 秒 | 横屏 16:9 | GitHub 把 Copilot 从代码补全工具升级成多智能体中控台,一次讲清它凭什么、又有什么坑

【分镜 1|开场钩子|0-5秒】

画面:GitHub Universe 发布会现场灯光亮起快切,Copilot 新 logo 闪现,接一个「AI 机器人团队开会」的动画

口播:Copilot 已经不帮你写代码了——它现在管着一支 AI 团队帮你写代码,你只负责在最后签字。

字幕:Copilot 变「AI 中控台」了?!

【分镜 2|背景铺垫|5-25秒】

画面:三格时间轴动画逐格点亮:2021 键盘敲代码 → 2023 对话气泡 → 2024 指挥台

口播:回顾 Copilot 的进化路径,是一条清晰的三段式曲线。2021 到 2023 年,它是代码补全工具,本质是更聪明的自动完成,开发者的态度是「有它挺好,没它也能活」。2023 到 2024 年,Copilot Chat 加入,它开始主动对话,帮你描述需求、生成测试、解释遗留代码。而现在,GitHub Universe 发布了重新设计的 Copilot,官方定位是——连接多个 AI 智能体的开发工作台。

字幕:2021 补全工具 → 2023 Chat 助手 → 2024 多智能体工作台

【分镜 3|核心解析|25-60秒】

画面:架构动画:开发者提目标 → Copilot Projects 拆任务 → 编码/测试/审查三个智能体并行跑 → 结果汇回人类审核;末尾特写伪代码最后一行

口播:这次的核心新功能叫 Copilot Projects。它干三件事:第一,项目级上下文,智能体不再只看你当前打开的文件,而是理解整个项目的结构、依赖和历史。第二,任务拆解与分发,你提出的目标会被拆成多个子任务,交给不同智能体并行处理。第三,结果汇总,多个智能体的产出汇到统一界面,由你审核合并。注意,伪代码里最后一句写的是 reviewer 等于 human——人类必须在关键决策点签字,这是目前所有智能体产品都绕不过的红线。

字幕:三大机制:项目级上下文 / 任务拆解 / 人类审核(reviewer="human")

【分镜 4|延伸对比|60-85秒】

画面:左边 GitHub 图标压住整张开发流程图(PR、CI、issue),右边 LangGraph、CrewAI、AutoGen 三个 logo 淡入;随后切红色警告动画:bug 被「确认」被「放行」,token 消耗数字飙升

口播:市面上做多智能体编排的工具不少,LangGraph、CrewAI、AutoGen 都有相当声量。但 GitHub 有别人不具备的优势:超过 1 亿开发者在它上面托管代码,写代码、跑测试、提 PR、过 CI,这些动作的原生载体就是 GitHub——它不需要接入开发流程,它本身就是流程;issue 历史、PR 讨论这些语义数据也沉淀在平台内。但泼点冷水:一个编码智能体引入的 bug,可能被测试智能体的错误断言「确认」,再被审查智能体「放行」,这种级联错误比单智能体时代更难治理。成本也是问题——一次 Projects 任务的调用量,可能是单次 Chat 的十倍以上。

字幕:1 亿开发者的主场 | 警惕:级联错误 + 10 倍 token 消耗

【分镜 5|总结+三连|85-100秒】

画面:指挥官视角俯瞰 AI 团队,镜头拉近到「人」按下最终签字按钮

口播:这次发布更像一次宣言:软件开发的生产单元,正在从「人加工具」变成「人加智能体团队」。有观点推测,行业可能需要新技能——Agent Engineering,教你怎么精确描述任务、设计验收标准、在多个智能体之间做仲裁。记住这句话:工具越强大,使用工具的人的判断力就越值钱。如果你也想站在指挥位而不是打字段,三连一下,下期拆解智能体编排的实战玩法。

字幕:工具越强,人的判断力越值钱|三连解锁下期

【弹幕互动点】

1. 分镜 3 结尾:把「reviewer = human」这句话打在公屏上——你觉得最终签字权该不该交给 AI?

2. 分镜 4 结尾:弹幕扣「1」表示愿意为十倍 token 买单,扣「2」表示先观望。

【BGM与节奏】前 25 秒用科技感渐强电子乐配合时间轴推进;核心解析段切节奏明确的 lo-fi beats 保持信息密度;60 秒泼冷水处 BGM 抽空 1 秒制造停顿,再进低音鼓点;结尾回升收束。关键数字(1 亿、十倍)处口播刻意放慢并停半拍。

【素材清单】

  • GitHub Universe 发布会现场画面(可用官方发布会录屏片段)
  • 【配图建议:三格时间轴动画:代码补全 → 对话气泡 → 多智能体指挥台】
  • 【配图建议:Copilot Projects 架构图:开发者—工作台—三个智能体的分发与汇总示意】
  • 【配图建议:伪代码特写,高亮最后一行 reviewer="human"】
  • LangGraph、CrewAI、AutoGen 三个工具的 logo 素材
  • 【配图建议:红色警告动画:bug 流经编码→测试→审查三关却被层层放行】
  • 【配图建议:指挥官俯瞰视角 + 最终签字按钮特写】

来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

【视频脚本总览】总时长 45-60 秒 | 竖屏 9:16 | 一句话定位:GitHub 把 Copilot 从补代码的工具升级成管一支 AI 团队的工作台,写代码的都得看一眼。

【分镜 1|0-3秒|利益点开场】

画面:手机屏幕怼脸拍,博主手指点着屏幕,表情夸张,背景闪过 GitHub 页面录屏

口播:写代码的兄弟听好了——GitHub 刚把 Copilot 从“帮你补代码的”,改成了“管一队 AI 干活的”,你的活儿要变天了。

字幕:Copilot 变天了!从副驾驶变指挥官

【分镜 2|3-30秒|正文讲清】

画面:分屏动画:左边一个程序员小人,右边三个 AI 小人排队领任务,逐个亮灯

口播:这事儿是在 GitHub Universe 大会上发布的,新功能叫 Copilot Projects。以前 Copilot 就是行内补全,后来能跟你对话,现在呢?你提一个目标,它直接拆任务派活儿:一个 AI 写代码、一个跑测试、一个做审查,仨智能体并行开工,结果汇总到一块儿。但注意,最后审核签字的还是你,机器说了不算。GitHub 凭啥敢干这个?因为超过 1 亿开发者在它平台上托管代码,issue、PR、代码评审全在它家里,它本身就是开发流程。不过我也得泼盆冷水:多个 AI 一起干活,错误也会一起放大;而且一次任务的调用量,可能是单次聊天的十倍以上,真不是按个按钮就躺平。

字幕:Copilot Projects:AI 写 / AI 测 / AI 审 / 你签字|超 1 亿开发者|调用量可能是 Chat 的十倍以上

【分镜 3|30-45秒|实在收尾】

画面:博主回归正面出镜,坐在电脑前,背景是代码编辑器

口播:说句实在话,工具越强大,会用工具、敢下判断的人就越值钱。你与其焦虑被替代,不如琢磨怎么当好那个“指挥官”。评论区聊聊:你现在用 AI 写代码,写到什么程度了?是补个行,还是直接让 AI 干整块活儿?

字幕:工具越强,判断力越值钱|你用到哪一步了?

【BGM与节奏】前 3 秒用带鼓点的卡点音乐抓耳;正文中速偏快,讲“三个 AI 分工”时逐个停顿强调;泼冷水部分节奏放慢半拍,收尾恢复轻快,结尾一句上扬留互动感。

【素材清单】

1. GitHub Universe 大会或 Copilot 页面录屏(可用简报配图做封面或贴片:【配图建议:Copilot 相关发布会画面截图】)

2. 三智能体分工示意动画(写/测/审三个色块小人)

3. 字幕高亮贴纸:Copilot Projects、超 1 亿开发者、十倍以上调用量

4. 博主真人出镜片段(开场怼脸 + 结尾坐机位)


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

GitHub 把 Copilot 改成“AI 中控台”:一次 Projects 任务可能是十倍 Chat 调用量,这笔账开发者必须算清楚

GitHub Universe 大会上,GitHub 官方给重新设计的 Copilot 定了一个新身份:连接多个 AI 智能体的开发工作台。不再是帮你补全代码的副驾驶,而是一个调度 AI 团队的中控台。核心新功能叫 Copilot Projects。但这套架构有一个绕不开的账本——一次 Projects 任务的调用量,可能是单次 Chat 的十倍以上。功能很性感,成本很真实。

一、三次进化:Copilot 怎么走到今天

理解 Copilot Projects,先看它走过的三段路:

  • 2021-2023:代码补全工具。 核心场景是行内补全,本质是“更聪明的自动完成”。当时开发者对它的态度是“有它挺好,没它也能活”。
  • 2023-2024:Chat 对话助手。 Copilot Chat 让它从被动补全走向主动对话,开发者开始用自然语言描述需求、生成测试、解释遗留代码。
  • 2024 至今:多智能体工作台。 这次 GitHub Universe 发布的核心。Copilot 从“单个助手”变成“智能体编排平台”——你不再和一个 AI 对话,而是在指挥一支 AI 团队。

二、机制拆解:Projects 的三个环节

根据 Dev.to 的报道,官方细节仍在陆续放出,但从架构思路上看,Copilot Projects 的核心逻辑是三步:

1. 项目级上下文:智能体不再只看到你当前打开的文件,而是理解整个项目的结构、依赖和历史。

2. 任务拆解与分发:开发者提出的目标被拆解为多个子任务,由不同智能体并行处理。

3. 结果汇总与校验:多个智能体的产出汇聚到统一界面,由开发者审核合并。

用一个示意性的编排结构来描述这套思想(注意:这是伪代码示意,不是官方实现):

# 多智能体编排示意(伪代码)
class CopilotProject:
    def __init__(self, goal: str, repo: Repo):
        self.goal = goal          # 开发者的高层目标
        self.repo = repo          # 项目级上下文
        self.agents = load_agents(["coder", "tester", "reviewer"])

    def run(self):
        # 1. 任务拆解:把目标变成可分发的子任务
        tasks = self.plan(self.goal, context=self.repo.context())

        # 2. 并行分发:各智能体独立执行
        results = {}
        for agent, task in zip(self.agents, tasks):
            results[agent.name] = agent.execute(
                task, 
                context=self.repo.context(),
                shared_state=self.shared_state  # 智能体间共享状态
            )

        # 3. 汇总校验:人类做最终裁决
        return self.aggregate(results, reviewer="human")

这段伪代码里最关键的一行是 reviewer="human"。这不是炫技,而是目前所有智能体产品都无法绕过的红线:人类必须在关键决策点签字。

【配图建议:开发者—Copilot Projects 工作台—编码/测试/审查三类智能体的调度架构示意图】

三、为什么是 GitHub 来做这件事

市面上做多智能体编排的工具不少:LangGraph、CrewAI、AutoGen 都在开发者社区有相当声量。但 GitHub 有三张别人没有的牌:

1. 它就是流程本身。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI——这些动作的原生载体就是 GitHub,不需要“接入”开发流程。

2. 数据护城河。 智能体理解项目上下文需要 issue 历史、PR 讨论记录、Code Review 评论,这些语义信息大量沉淀在平台内,第三方工具很难完整获取。

3. 商业闭环现成。 Copilot 的订阅付费模式已经验证,多智能体能力可直接叠加到现有订阅体系上。

四、两个硬风险,写代码前先想清楚

风险一:级联错误(error cascading)。 多个智能体并行工作,意味着错误也会被“并行放大”。一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,最后由审查智能体“放行”——三个环节全绿灯,代码却是错的。这种治理难度比单智能体时代更高。 风险二:成本结构。 一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上(注意这是原文的“可能”表述,非实测数据)。GitHub 的订阅定价能否覆盖这个成本结构,还需观察。

五、实践建议:从 Prompt Engineering 到 Agent Engineering

“指挥官”听起来很酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。对开发者,我的落点建议是三件事:

1. 精确描述任务:把“帮我修这个 bug”拆成带验收标准的任务描述,这是智能体能否正确执行的第一个分水岭。

2. 设计验收标准:既然你是最终 reviewer,就要事先定义什么算“通过”,否则汇总校验环节形同虚设。

3. 练习仲裁:在多个智能体的产出之间做判断,会是未来日常工作中占比越来越高的动作。

软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”。这个判断的方向大概率是对的,但节奏可能比发布会 PPT 上呈现的要慢。

最后带走一个观点:工具越强大,使用工具的人的判断力就越值钱。 架构判断力、业务理解力、以及那个“最终签字的人”的审慎——守住这三样,你才是指挥官;丢掉它们,你只是给 AI 团队换了个工位。

来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

Copilot Projects:GitHub 把你从打字员变成签字的人

伪代码最后一行写着 reviewer="human"——这是 GitHub Universe 上最值得开发者琢磨的一件事:Copilot 从帮你补全代码的副驾驶,变成了调度多智能体的工作台,而人类被钉在了最终裁决位上。

为什么值得关注

先看 Copilot 的三段进化,理解这次为什么是质变:

  • 2021-2023,行内补全:本质是“更聪明的自动完成”,态度是“有它挺好,没它也能活”
  • 2023-2024,Chat 对话助手:用自然语言描述需求、生成测试、解释遗留代码,从被动走向主动
  • 2024 至今,多智能体工作台:本次发布的核心,官方表述是“连接多个 AI 智能体的开发工作台”

前两阶段你都在和一个 AI 协作,这次你在指挥一支 AI 团队。协作模式变了,你的工作流也得跟着变。

技术拆解:编排怎么做

据 Dev.to 报道,新功能叫 Copilot Projects,官方细节仍在陆续放出,但从架构思路看逻辑是三步:

1. 项目级上下文:智能体不只看你打开的文件,而是理解整个项目的结构、依赖和历史

2. 任务拆解与并行分发:你的目标被拆成多个子任务,编码、测试、审查智能体各领一块

3. 结果汇总,人类审核合并

原文用一段伪代码把编排思想讲得很清楚:

class CopilotProject:
    def __init__(self, goal: str, repo: Repo):
        self.goal = goal          # 开发者的高层目标
        self.repo = repo          # 项目级上下文
        self.agents = load_agents(["coder", "tester", "reviewer"])

    def run(self):
        # 1. 任务拆解:把目标变成可分发的子任务
        tasks = self.plan(self.goal, context=self.repo.context())

        # 2. 并行分发:各智能体独立执行
        results = {}
        for agent, task in zip(self.agents, tasks):
            results[agent.name] = agent.execute(
                task, 
                context=self.repo.context(),
                shared_state=self.shared_state  # 智能体间共享状态
            )

        # 3. 汇总校验:人类做最终裁决
        return self.aggregate(results, reviewer="human")

多智能体编排这事 LangGraph、CrewAI、AutoGen 都在做,但 GitHub 的生态位没人能复制:

  • 超过 1 亿开发者在上面托管代码。智能体要写代码、跑测试、提 PR、过 CI,这些动作的原生载体就是 GitHub——它不需要“接入”开发流程,它本身就是流程
  • 数据护城河:智能体理解上下文需要 issue 历史、PR 讨论、Code Review 评论,这些语义信息沉淀在 GitHub 内部,第三方很难完整拿到
  • 商业闭环现成:Copilot 订阅付费已验证,多智能体能力直接叠加进去就行

泼点冷水

级联错误比单智能体更难治。多个智能体并行工作,错误也被并行放大:一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,再被审查智能体“放行”。整条流水线看起来运转正常,实际是一路错的。 成本可能翻倍不止。多智能体意味着多倍 token 消耗,原文的估计是一次 Projects 任务的调用量可能是单次 Chat 的十倍以上。订阅定价能不能覆盖这个成本结构,还得观察。

对你日常开发的启示

“指挥官”听起来很酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。Prompt Engineering 之后,行业可能需要新技能——"Agent Engineering":怎么精确描述任务、怎么设计验收标准、怎么在多个智能体的产出之间做仲裁。

工具越强大,使用工具的人的判断力就越值钱。架构判断力和业务理解力,短期内还是你自己的核心竞争力。


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

GitHub Copilot 变身 AI 中控台了吗?GitHub Universe 大会给出了答案

答案是:是的。在 GitHub Universe 大会上,GitHub 官方宣布重新设计的 Copilot 定位为连接多个 AI 智能体的开发工作台,核心新功能叫 Copilot Projects。一句话概括:Copilot 不再只是帮你补全代码的“副驾驶”,而是变成了一个调度多支 AI 团队的指挥台。

配图

【配图建议:GitHub Universe 大会现场或 Copilot 工作台界面截图】

Copilot 是怎么走到这一步的?

回顾它的进化路径,是一条清晰的三段式曲线:

  • 2021-2023:代码补全工具。 核心场景是行内补全,本质是“更聪明的自动完成”。开发者的态度是“有它挺好,没它也能活”。
  • 2023-2024:Chat 对话助手。 Copilot Chat 加入后,它从被动补全走向主动对话,开发者开始用自然语言描述需求、生成测试、解释遗留代码。
  • 2024 至今:多智能体工作台。 也就是本次 GitHub Universe 发布的重点。

第三阶段的真正意义在于:你不再是和一个 AI 对话,而是在指挥一支 AI 团队。

Copilot Projects 是怎么工作的?

根据 Dev.to 的报道,新特性把 Copilot 重构为多智能体工作区,核心逻辑有三层:

1. 项目级上下文——智能体不再只看你当前打开的文件,而是理解整个项目的结构、依赖和历史;

2. 任务拆解与分发——你提出的目标被拆成多个子任务,交给不同智能体并行处理,比如编码智能体实现功能、测试智能体生成用例、审查智能体做代码审查和安全扫描;

3. 结果汇总与校验——所有产出汇聚到统一界面,由你审核合并。

注意最后一步:最终审核者是“human”(人类)。这不是炫技,而是目前所有智能体产品都无法绕过的红线——人类必须在关键决策点签字。

配图

为什么这件事由 GitHub 来做最合适?

市面上做编排的工具不少,LangGraph、CrewAI、AutoGen 在开发者社区都有声量。但 GitHub 有三个别人没有的优势:

第一,它坐拥代码世界的“操作系统”地位。 超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI,这些动作的原生载体就是 GitHub。它不需要“接入”开发流程,它本身就是流程。 第二,数据护城河。 智能体要理解项目上下文,靠的是 issue 历史、PR 讨论记录、Code Review 评论——这些语义信息大量沉淀在 GitHub 平台内,第三方工具很难完整获取。 第三,商业闭环现成。 Copilot 已经验证了订阅付费模式,多智能体能力可以直接叠加到现有订阅体系上。

但要泼三盆冷水

1. 可靠性未解。 多个智能体并行工作,错误也会被“并行放大”:一个编码智能体引入的 bug,可能被测试智能体的错误断言“确认”,再被审查智能体“放行”。这种级联错误的治理,比单智能体时代更难。

2. 成本不低。 多智能体意味着多倍 token 消耗,一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上。订阅定价能否覆盖,还需观察。

3. 新技能要求。 “指挥官”听着酷,但指挥一支不可靠的 AI 团队,可能比亲自写代码更累。Prompt Engineering 之后,行业可能需要新技能:Agent Engineering——如何精确描述任务、设计验收标准、在多个智能体的产出之间做仲裁。

总结

这次发布的本质是一次宣言:软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”。方向大概率是对的,但节奏可能比发布会 PPT 呈现的更慢。

给开发者的建议很直接:拥抱工具演进,但守住架构判断力、业务理解力,以及那个“最终签字的人”的审慎。工具越强大,使用工具的人的判断力就越值钱。


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

深夜的 GitHub Universe 发布会直播,我盯着屏幕,心里咯噔了一下:那个叫了四年“副驾驶”的 Copilot,被 GitHub 当场“升职”了。官方的说法是,它被重新定位为连接多个 AI 智能体的开发工作台,还带来了一个新名字——Copilot Projects。

副驾驶变中控台。这四个字的落差,比发布会 PPT 上任何一页都冲击我。

配图

【配图建议:GitHub Universe 发布会现场或 Copilot 界面截图】

回想我第一次用 Copilot,是 2021 年前后的事。那时它就是个行内补全工具,本质是“更聪明的自动完成”。用它的时候心态很平淡:有它挺好,没它也能活。到了 2023 年,Copilot Chat 出现,我开始用自然语言描述需求、让它生成测试、解释那些没人敢碰的遗留代码。它从被动补全走向主动对话,像一个话多的同事。

而现在,2024 年以来,它要变成一支团队。

据 Dev.to 的报道,Copilot Projects 的逻辑大致是三步:第一,智能体不再只看你当前打开的文件,而是理解整个项目的结构、依赖和历史;第二,你提出的目标会被拆解成多个子任务,由不同的智能体并行处理;第三,所有产出汇聚到统一界面,由你审核合并。

最后那一步让我停了很久——审核合并,签字的是人。原文里有句话我抄在了备忘录里:人类必须在关键决策点签字。这不是流程装饰,这是目前所有智能体产品绕不过去的红线。

有人会问:做多智能体编排的工具不少啊,LangGraph、CrewAI、AutoGen 都有声量,凭什么 GitHub 来做?

我想到三个别人给不了的答案。其一,超过 1 亿开发者在 GitHub 上托管代码。智能体要写代码、跑测试、提 PR、过 CI,这些动作的原生载体就是 GitHub——它不需要“接入”开发流程,它本身就是流程。其二,issue 历史、PR 讨论、Code Review 评论,这些让智能体理解项目上下文的语义信息,大量沉淀在平台内,第三方很难完整拿到。其三,Copilot 已经跑通了订阅付费,新能力直接叠加就行,商业闭环是现成的。

但今晚我没法只兴奋。多智能体意味着错误也会被“并行放大”——一个编码智能体写出的 bug,可能被测试智能体的错误断言“确认”,再被审查智能体“放行”。级联错误的治理,比单智能体时代难得多。还有钱的问题:一次 Projects 任务跑下来,调用量可能是单次 Chat 的十倍以上,订阅定价能否覆盖,没人知道。

以及最扎心的一个问题:“指挥官”听起来威风,可指挥一支不可靠的 AI 团队,说不定比自己写代码更累。Prompt Engineering 之后,行业大概需要新技能——Agent Engineering:精确描述任务、设计验收标准、在多个智能体的产出之间做仲裁。

【配图建议:开发者深夜面对多窗口界面的场景感画面】

关掉直播时我想明白了一件事。软件开发的生产单元,正在从“人+工具”变成“人+智能体团队”,这个方向大概率是对的——但节奏可能比发布会呈现的慢得多。与其焦虑被替代,不如守住三样东西:架构判断力、业务理解力,还有那个“最终签字的人”的审慎。

工具越强大,使用工具的人的判断力就越值钱。

这句话,值得带进下一个十年。


来源:Dev.to《GitHub turns Copilot into a multi-agent workspace with new Projects feature》(https://dev.to/delimitter/github-turns-copilot-into-a-multi-agent-workspace-with-new-projects-feature-5lh)

原文:https://www.rainbowonionai.cn/github-turns-copilot-into-a-multi-agent-workspace-with-new-p.html

🚀 多平台发布

点击「复制」获取平台专属文案,到各平台编辑器(App/网页)粘贴即可发布。
有密钥的 4 个平台(微信服务号 / 头条 / 百家号 / 微博)可自动发布,密钥填好后自动点亮。

平台状态操作
💬 公众号🔑 待配置密钥
🎵 抖音📋 手动复制
📕 小红书📋 手动复制
🤔 知乎📋 手动复制
📰 今日头条🔑 待配置密钥
🐦 微博🔑 待配置密钥
📺 B站📋 手动复制
⚡ 快手📋 手动复制
💻 CSDN📋 手动复制
⛏️ 掘金📋 手动复制
📝 百家号🔑 待配置密钥
✍️ 简书📋 手动复制