11-19 更新 实时
首页/ 技术栈/ 正文

超越代码生成:智能体工程开发者指南

技术栈 来源:GitHub Blog 2026-11-07 06:15 0 阅读 机器翻译

今年 10 月,GitHub 在一周内出现了超过 12 亿次提交——比一年前增加了 400% 以上。这一周的提交量比 GitHub 在整个 2025 年收到的提交量还要多。你很可能比一年前生成了更多代码。但请扪心自问:你觉得自己比去年高效了 400% 吗?

构建软件靠的不只是一句好的提示词。随着 AI 加快实现速度,软件开发人员在其它环节感受到的压力反而更大:Faros AI 的一项研究发现,当团队从低 AI 采用率转向高 AI 采用率时,拉取请求(pull request)停留在评审环节的时间延长了 441%。

作为软件开发人员,你要收集需求并引导实现,评审改动并评估测试结果,然后排查生产环境中发生了什么。智能体可以帮助你在所有这些阶段更高效地工作:规划(Plan)、构建(Build)、验证(Verify)和观察(Observe)。我们将带你了解在 GitHub 上,一套高效的智能体式工程工作流是什么样子。

看看下面这个场景是否似曾相识。你正在规划一项 API 变更。设计文档在一个工具里,兼容性要求埋在 Slack 的聊天记录中,而一个旧的拉取请求解释了当前实现为何是这样。在写出有用的方案之前,你需要把这些细节串起来,比较不同做法,并就现有客户端如何继续正常工作达成一致。原本看似简单的规划任务,变成了数小时的搜索、交叉核对和四处追问。还没开始实现,你就已经精疲力竭。

你可以用 Copilot 把这些零散的上下文汇集到一处,梳理各种取舍,并把决策转化为一份实现方案。

过去需要花上数天搜索和收集上下文的工作,如今能产出一份可供审阅的计划、明确的验收标准以及划定范围的问题,而你的时间则花在决策上,而不是检索上。随后,一旦你确定了方案,你其实已经为自己和你的智能体做好了实施这份计划的准备。

你已准备好把这份计划变成代码。但生活总有别的安排。你的智能体任务才做到一半,下一场会议五分钟后就开始,而你的狗已经盯着门口看了二十分钟。接着会上有人指出一个实现需要处理的边界情况。每个人都在同一时间有求于你。你想继续推进,却又分身乏术。

你可以让工作持续向前推进,而不必被束缚在最初开始工作的那台电脑前。

写代码不只是向你的 LLM 抛出一个提示词、看看返回什么那么简单。而当你手上的活儿比以往任何时候都多时,要维持自己的编码标准并按时交付项目就更难了。Copilot 借助共享的项目知识,让任务能够独立推进,同时让你跨设备从上次中断的会话继续。这让你有更多余地去推敲实现决策,并在变化出现时及时应对。当你的工作完成时,已有聚焦的变更可供审阅。

你花了一个小时调教你的智能体,让它们朝正确的方向推进,以为总算落到了一个不错的状态。于是你开了一个标着「小幅重构」的 pull request。它改动了 47 个文件。你本想就共享的校验逻辑征求意见,可它却淹没在每一个调用它的端点的改动、格式调整,以及几百行自动生成的测试里。你不禁想,鉴于团队评审看板上那看不到头的 pull request 列表,这份改动要多久才能拿到批准。

那条评审队列就是现实中的 441%。你可以从两端缩短等待:让自己的改动更容易被人工评审,同时让 Copilot 在任何人打开 diff 之前就把常规检查和修复处理掉。

改动更小、常规工作已经处理完毕,意味着更少的来回往复。评审者就能把注意力放在代码是否实现了你的意图,以及哪里可能出问题。

你的改动通过了批准,部署检查也过了,你终于可以把它从清单上划掉。第二天早上,你的值班看板显示出间歇性超时,支持团队报告有几家大客户受到影响。现在你一边比对日志、发布历史和客户反馈,一边还得应付有人问要不要回滚。「所有检查均已通过」这句话,已经不像昨天那样让人安心了。

把运维证据与工程上下文放在一起,才能决定该怎么做。

弄清一次发布之后究竟发生了什么,可能会让你在仪表盘、对话记录和提交历史之间来回切换。有了 Copilot 帮忙串联这些信息,你可以把发现的情况记录下来、创建后续 issue,并改进可供未来任务使用的指引。你花更多时间决定需要改什么,花更少时间去回溯调查过程。而你的下一份计划,就从你从用户实际正在使用的那款软件中学到的东西开始。

拿一件已经在你手头的工作,把视野放到编码任务之外。它需要哪些上下文?你将如何审查和测试它?上线之后你又如何知道它奏效了?

你不必一次性改变整个流程。从这周最让你头疼的一件事开始,让一个智能体来处理它,然后再随着时间推移扩展到流程的其他部分。一旦智能体在你整个工作流中提供帮助,你也许终于会感觉自己效率配得上提交次数所显示的水平。

我们在 GitHub Universe 2026 上以“Agentic Engineering: Past the Pilot”为主题进行了现场讨论。

开始使用 Copilot >

文章《超越代码生成:面向开发者的智能体式工程指南》最初发布于 The GitHub Blog。

译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。

查看英文原文(Beyond code generation: A developer’s guide to agentic engineering)

This October, GitHub saw more than 1.2 billion commits in one week—over 400% more than a year earlier. This is more commits than GitHub received in all of 2025. Chances are, you’re generating more code than you were a year ago. But ask yourself: do you feel 400% more productive than you were last year?

Building software takes more than a good prompt. As AI speeds up implementation, software developers are feeling more pressure in other places: a Faros AI study found that pull requests spent 441% longer in review when teams went from low to high AI adoption.

As a software developer, you gather requirements and steer implementation, review changes and evaluate test results, then investigate what happens in production. Agents can help you work more efficiently across all of these stages: Plan, Build, Verify, and Observe. We’ll walk through what an effective agentic engineering workflow looks like on GitHub.

Plan: Get everyone and every agent on the same page

See if this sounds familiar. You’re planning an API change. The design is in one tool, a compatibility requirement is buried in Slack, and an old pull request explains why the current implementation works this way. Before you can write a useful plan, you need to connect those details, compare approaches, and agree on how existing clients will keep working. What looked like a straightforward planning task has become hours of searching, cross-checking, and chasing answers. You’re exhausted before implementation even begins.

You can use Copilot to pull that scattered context into one place, work through the tradeoffs, and turn the decisions into an implementation plan.

  • Plan together where your team already works. Use Copilot in Slack or Teams to collaborate with everyone involved—from product managers and designers to analysts and business stakeholders. Bring in context from connected tools so your team can check assumptions, contribute ideas, and refine requirements together.
  • Turn agreed-upon requirements into actionable work. Ask Copilot to create GitHub Issues with the context and acceptance criteria needed for implementation, breaking out tasks that can be handled separately.
  • Keep routine triage from consuming planning time. Use GitHub Agentic Workflows to label your issues and estimate task complexity. Assign low-complexity tasks directly to Copilot, then spend your time focusing on harder decisions.
  • Give complex work the planning it needs. Use Plan Mode in your preferred Copilot surface to compare approaches and refine an implementation plan. Review and approve the plan before handing it off to Copilot to begin implementation.

What took days of searching and context gathering now produces a reviewable plan, explicit acceptance criteria, and scoped issues, with your time spent on the decisions instead of the retrieval. Then, once you settle on an approach, you’ve already set yourself and your agents up to implement your plan.

Build: Move more than one task forward at a time

You’re ready to turn that plan into code. But life has other ideas. Your agent is halfway through a task, your next meeting starts in five minutes, and your dog has been staring at the door for twenty. Then someone in the meeting points out an edge case the implementation needs to handle. Everyone needs something from you at once. You’d like to keep making progress, but you can’t be in three places at the same time.

You can keep your work moving without being tied to the computer where you started it.

  • Continue your conversation from another device. Session continuity lets you pick up the same Copilot session across clients, so you can work wherever it’s most convenient for you.
  • Let work continue after you close your laptop. Copilot runs tasks in cloud sandboxes, keeping execution off your machine and allowing you to leave and return to a session later.
  • Work on separate tasks without mixing their edits. The Copilot app gives sessions isolated copies of the repository, so an implementation task and a documentation update don’t share an unfinished working tree.
  • Carry project knowledge into each task. Repository instructions capture conventions and validation commands, while shared memory stores useful facts Copilot can reuse across a repository. Copilot Dreaming reviews eligible sessions and pull request feedback to keep memories current and propose instruction or skill updates. That means less time re-explaining how your team works and more consistent help from Copilot across tasks.
  • Match the models to the work. Select Copilot Fusion to choose models and reasoning depth for the task, bringing in additional models to review a solution when needed. You set the effort level to balance quality, cost, and response time.
  • Follow company rules wherever you work. Enterprise managed settings carry your company’s policies and configured tools across Copilot surfaces, reducing setup differences as you move between clients.

Writing code is more than shooting off a single prompt to your LLM and seeing what you get back. And with more work on your plate than ever, it can be difficult to maintain your coding standards and deliver your projects on time. Copilot helps tasks progress independently with shared project knowledge, while letting you pick up a session where you left off across devices. That gives you more room to work through implementation decisions and handle changes as they come up. And as your work finishes, you have focused changes ready to review.

Verify: Spend your attention where it counts

After spending an hour wrangling your agents to get them moving in the right direction, you think you’ve all landed in a good spot. So you open a pull request labeled “small refactor.” It changes 47 files. You wanted feedback on shared validation logic, but it’s buried among updates to every endpoint that calls it, formatting changes, and several hundred lines of generated tests. You wonder how long it will take to get an approval on this, given the endless list of pull requests on your team’s review board.

That review queue is the 441% in practice. You can shorten the wait from both ends: make your changes easier for a person to review, and let Copilot clear the routine checks and fixes before anyone opens the diff.

  • Stack up smaller, more focused pull requests instead of creating a single, massive change. You and your agents can use stacked pull requests to separate dependent work into smaller pieces. This lets each PR be reviewed on its own, keeps dependencies visible, and unblocks teams by letting them build on top of your work before it merges.
  • Catch routine quality issues before they consume review time. GitHub Code Quality checks changes against coding practices and your organization’s standards, catching issues before they reach a human reviewer and saving time for both authors and reviewers.
  • Get review help matched to the change. Copilot code review gives automated feedback, with lighter analysis for simple changes and deeper analysis for complex ones. You can set that depth yourself or let Copilot select it for each pull request.
  • Check security across more of your codebase. AI Scan finds vulnerabilities in languages and files beyond CodeQL’s coverage. AI secret detection helps identify unstructured secrets, such as passwords, that pattern matching can miss.
  • Keep new dependencies within policy. License compliance checks dependency licenses against your company’s rules before merging. GitHub package firewall, currently in public preview for npm, can block downloads that violate configured security policies.
  • Resolve findings and follow-up work without babysitting every pull request. Agentic Autofix proposes repairs for security issues, while Agent Merge automatically addresses failing checks, review comments, and merge conflicts—helping you keep your pull requests moving and preparing them for merge. And, if you configure it, Copilot will even merge your pull requests once your verification steps are passing.

Smaller changes with the routine work already handled means fewer rounds of back-and-forth. Your reviewers get to spend their attention on whether the code does what you intended, and what could go wrong.

Observe: Learn from what happens after you ship

Your change gets approved, the deployment checks pass, and you finally get to cross it off your list. The next morning, your on-call dashboard shows intermittent timeouts, and support reports that a few large customers are affected. Now you’re comparing logs, release history, and customer reports while someone asks whether you should roll back. “All checks passed” feels less reassuring than it did yesterday.

Bring operational evidence and engineering context together so you can decide what to do.

  • Check assumptions against real behavior. With access to your observability tools and business data through connectors such as Fabric, Copilot can help investigate which requests or customer groups are affected.
  • Capture the finding where someone can act on it. Ask Copilot to draft an issue with supporting evidence and acceptance criteria, including a regression test for the failure you uncovered.
  • Carry useful lessons into future work. Review suggested improvements from Dreaming, which uses sessions and repository activity to help refine memories, skills, and code review guidance.

Figuring out what happened after a release can leave you bouncing between dashboards, conversations, and commit history. With Copilot helping connect that information, you can document what you found, create follow-up issues, and improve the guidance available for future tasks. You spend more time deciding what needs to change and less time retracing the investigation. And your next plan starts with what you learned from the software people are actually using.

Where to start

Take one piece of work already on your plate and look beyond the coding task. What context does it need? How will you review and test it? How will you know it worked after it ships?

You don’t have to change your whole process at once. Start with something that frustrates you most this week and put an agent on it. Then expand to other parts of your process over time. Once agents are helping across your whole workflow, you might finally feel as productive as your commit count says you are.

We covered this topic live at GitHub Universe 2026 in “Agentic Engineering: Past the Pilot.”

The post Beyond code generation: A developer’s guide to agentic engineering appeared first on The GitHub Blog.

正文保留英文原文,标题与摘要由机器翻译。

本文由采集器自动同步

原文发布于 GitHub Blog(Beyond code generation: A developer’s guide to agentic engineering),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。

阅读原文 ↗