Velocity in writing code has surged, yet the broader software delivery process remains sluggish. A glance at GitHub's infrastructure tells the story: in October, the platform recorded more than 1.2 billion commits in a single week—a 400% jump from the same period a year prior, and more than the entire volume for 2025. Yet developers report feeling far from 400% more productive. The bottleneck has shifted. Research from Faros AI reveals that pull request review times ballooned by 441% when teams transitioned from low to high AI adoption, exposing a gap between implementation speed and the human judgment required elsewhere in the workflow.

The full lifecycle of software development spans four distinct phases where agents can amplify human decision-making: planning requirements, building implementation, verifying changes, and observing production behavior. Each stage presents opportunities to offload routine work while preserving the judgment calls that matter most.

Plan: Consolidating scattered context into actionable direction

Planning an API change typically means hunting across multiple systems. Design documents live in one tool, compatibility constraints hide in Slack threads, and historical context about why the current code works a certain way sits in an old pull request. Developers spend hours cross-referencing these fragments before they can even sketch an implementation approach. Copilot can gather this dispersed information into a single workspace, work through the tradeoffs, and produce a concrete plan.

  • Collaborate within existing team spaces using Copilot in Slack or Teams, bringing context from connected tools so product managers, designers, analysts, and stakeholders can validate assumptions and refine requirements together.
  • Convert agreed requirements into scoped GitHub Issues with acceptance criteria and task breakdowns that can proceed in parallel.
  • Automate routine issue triage with GitHub Agentic Workflows to apply labels and complexity estimates, freeing human attention for harder decisions.
  • Use Plan Mode to compare implementation approaches and refine strategy before handing execution off to agents.

The result: days of searching compress into a reviewable plan with explicit criteria and scoped work, with human effort concentrated on the decisions rather than the retrieval.

Build: Maintaining progress across interruptions and devices

Implementation rarely proceeds uninterrupted. An agent is midway through a task when a meeting starts, a new edge case emerges mid-discussion, and competing demands pull focus in multiple directions. Developers need the ability to keep work advancing without being physically tethered to a single machine.

  • Resume the same Copilot session across different devices, allowing work to continue wherever is most practical.
  • Execute tasks in cloud sandboxes so progress continues after the developer closes their laptop, with the option to return and inspect results later.
  • Maintain isolated repository copies per session, preventing an implementation task and a documentation update from interfering with each other's working tree.
  • Embed project knowledge through repository instructions that capture team conventions and validation commands, while shared memory stores facts Copilot reuses across tasks. Copilot Dreaming reviews sessions and pull request feedback to keep this knowledge current.
  • Select Copilot Fusion to choose specific models and reasoning depth for each task, bringing in additional models for review when needed.
  • Apply enterprise managed settings across all Copilot surfaces to enforce company policies and configured tools consistently.

This approach lets multiple tasks progress independently with shared project knowledge, while developers pick up where they left off. The result is more room for implementation decisions and handling changes as they arrive, with focused, reviewable changes ready when work completes.

Verify: Reducing review friction and catching issues early

A pull request labeled "small refactor" touches 47 files. The intended feedback target—shared validation logic—is buried under endpoint updates, formatting changes, and hundreds of generated test lines. The review queue grows longer. Shortening wait times requires action from both ends: making changes easier to review and letting Copilot handle routine checks before human reviewers see the diff.

  • Stack smaller, focused pull requests instead of bundling dependent work into a single massive change, keeping dependencies visible and unblocking teams.
  • Run GitHub Code Quality checks to catch coding practice violations and organizational standards issues before human review.
  • Apply Copilot code review for automated feedback, with analysis depth matched to change complexity.
  • Use AI Scan to find vulnerabilities in languages and files beyond CodeQL's coverage, and AI secret detection to identify unstructured secrets like passwords.
  • Enforce license compliance checks on new dependencies against company policy before merge.
  • Deploy GitHub package firewall (currently in public preview for npm) to block downloads violating configured security policies.
  • Configure Agentic Autofix to propose security issue repairs and Agent Merge to automatically address failing checks, review comments, and merge conflicts. Optionally allow Copilot to merge pull requests once verification steps pass.

Smaller changes with routine work already handled means fewer review cycles. Reviewers focus on whether the code achieves its intent and what could go wrong.

Observe: Connecting operational evidence to engineering decisions

A change merges, deployment checks pass, and the task moves to done. The next morning, the on-call dashboard shows intermittent timeouts affecting several large customers. Now comes the scramble: comparing logs, release history, and customer reports while deciding whether to roll back. Bringing operational data and engineering context together enables faster, more confident decisions.

  • Investigate which requests or customer groups are affected by accessing observability tools and business data through connectors such as Fabric.
  • Draft issues with supporting evidence and acceptance criteria, including regression tests for uncovered failures.
  • Review suggested improvements from Dreaming, which uses sessions and repository activity to refine memories, skills, and code review guidance for future work.

Post-release investigation no longer requires bouncing between dashboards and commit history. With Copilot connecting this information, developers document findings, create follow-up issues, and improve guidance for future tasks. The next planning cycle starts informed by what real users revealed.

Getting started

Pick one piece of current work and examine it beyond the coding task itself. What context does it require? How will it be reviewed and tested? How will success be measured after deployment? Transformation doesn't require overhauling the entire process at once. Start with the part that creates the most friction this week, assign an agent to it, then expand across other workflow stages over time. Once agents support the full cycle, developers may finally experience the productivity their commit counts suggest.