GitHub recorded more than 1.2 billion commits in a single week this October—over 400% more than a year earlier, and more than the platform received in all of 2025. Most developers are producing more code than they were last year. The open question is whether that translates into proportionally more productivity.

Writing software involves more than a good prompt. As AI accelerates implementation, pressure shifts elsewhere: a Faros AI study found that pull requests spent 441% longer in review when teams moved from low to high AI adoption. The work spans gathering requirements, steering implementation, reviewing changes, evaluating tests, and investigating production. Agents can assist across all of these stages—Plan, Build, Verify, and Observe.

Plan: align people and agents on the same context

Consider an API change. The design lives in one tool, a compatibility requirement sits buried in Slack, and an old pull request explains the rationale behind the current implementation. Writing a useful plan means connecting these details, comparing approaches, and agreeing on how existing clients keep working. The scattered-context problem can consume hours before implementation begins.

Copilot can consolidate that context, work through tradeoffs, and convert decisions into an implementation plan:

  • Plan in your team's existing tools. Copilot in Slack or Teams lets product managers, designers, analysts, and business stakeholders collaborate, pulling in context from connected tools to test assumptions and refine requirements.
  • Convert requirements into work items. Ask Copilot to create GitHub Issues containing the context and acceptance criteria needed for implementation, divided into tasks that can be handled separately.
  • Automate routine triage. GitHub Agentic Workflows can label issues and estimate task complexity. Low-complexity tasks can be assigned directly to Copilot, leaving harder decisions to you.
  • Give complex work a proper plan. Plan Mode, available in your preferred Copilot surface, compares approaches and helps refine an implementation plan, which you review and approve before handing it off for implementation.

The output is a reviewable plan, explicit acceptance criteria, and scoped issues—with your time going to decisions rather than retrieval. A settled approach also sets both you and your agents up for the build stage.

Build: keep multiple tasks moving

Implementation rarely happens in uninterrupted blocks. A meeting, an unexpected question, or an edge case someone raises can interrupt an agent mid-task. Progress shouldn't depend on remaining at the machine where you started.

  • Resume sessions from another device. Session continuity lets you pick up the same Copilot session across clients.
  • Continue after closing the laptop. Copilot executes tasks in cloud sandboxes, keeping execution off your machine so you can leave and return to a session later.
  • Isolate parallel tasks. The Copilot app gives each session an isolated copy of the repository, so an implementation task and a documentation update don't share an unfinished working tree.
  • Preserve project knowledge. Repository instructions capture conventions and validation commands, while shared memory stores facts Copilot reuses across a repository. Copilot Dreaming reviews eligible sessions and pull request feedback to keep memories current and to propose instruction or skill updates—reducing how often you re-explain team practices.
  • Right-size model effort. Copilot Fusion selects models and reasoning depth per task, can bring in additional models to review a solution, and lets you set the effort level balancing quality, cost, and response time.
  • Apply company rules consistently. Enterprise managed settings carry enterprise policies and configured tools across Copilot surfaces, reducing setup differences between clients.

With shared project knowledge and resumable sessions, tasks progress independently and produce focused changes ready for review, leaving you room for implementation decisions and last-minute shifts.

Verify: direct attention to what matters

A pull request labeled "small refactor" turns out to touch 47 files. The shared validation logic you wanted feedback on is buried among endpoint updates, formatting changes, and hundreds of lines of generated tests—and the team's review board already holds a long queue. That queue is the 441% in practice. The wait can be shortened from both ends: changes that are easier to review, and routine checks that Copilot completes before a human opens the diff.

  • Stack smaller pull requests. You and your agents can use stacked pull requests to separate dependent work into individual pieces, each reviewed on its own, with dependencies visible and teammates able to build on the work before it merges.
  • Screen for quality first. GitHub Code Quality checks changes against coding practices and organizational standards before they reach a reviewer.
  • Match review depth to the change. Copilot code review applies lighter analysis to simple changes and deeper analysis to complex ones, with depth set manually or selected by Copilot per pull request.
  • Extend security and policy checks. AI Scan finds vulnerabilities in languages and files beyond CodeQL's coverage, and AI secret detection catches unstructured secrets such as passwords that pattern matching misses. License compliance checks dependency licenses against company rules before merge, and GitHub package firewall—in public preview for npm—can block downloads that violate configured security policies.
  • Resolve findings without constant supervision. Agentic Autofix proposes repairs for security issues, while Agent Merge handles failing checks, review comments, and merge conflicts automatically. With your configuration, Copilot can also merge pull requests once your verification steps pass.

Smaller changes with routine work already handled reduce back-and-forth, so reviewers can concentrate on whether the code does what was intended and on what could go wrong.

Turning what happens after release into engineering input

Deployment checks pass and the change is approved, but the next morning brings intermittent timeouts on the on-call dashboard and support tickets from a handful of large customers. Deciding whether to roll back means correlating logs, release history, and customer reports — and at that point "all checks passed" carries little weight.

The goal is to put operational evidence and engineering context in the same place so a decision can actually be made.

  • Test assumptions against real behavior. With observability tools and business data reachable through connectors such as Fabric, Copilot can help narrow down which requests or customer groups are affected.
  • Record the finding where it can be acted on. Have Copilot draft an issue containing the supporting evidence and acceptance criteria, including a regression test for the failure that was uncovered.
  • Feed lessons into later work. Review the improvements suggested by Dreaming, which draws on sessions and repository activity to refine memories, skills, and code review guidance.

Instead of moving between dashboards, conversations, and commit history, you can document the finding, open follow-up issues, and improve the guidance future tasks will rely on. More of the time goes into deciding what should change; less goes into re-tracing the investigation. The next plan then begins with what the software in actual use has taught you.

Choosing a starting point

Pick one piece of work already on your plate and look past the coding step itself: which context does it require, how will it be reviewed and tested, and how will you confirm it worked once shipped?

There is no need to rework the entire process at once. Put an agent on whatever frustrated you most this week, then widen it to other parts of the workflow over time.

This topic was covered live at GitHub Universe 2026 in "Agentic Engineering: Past the Pilot." Details at the session page. To begin, see Get started with Copilot.