The landscape of software development is undergoing a seismic shift, characterized by an unprecedented surge in output. This past October, GitHub recorded an astounding milestone: more than 1.2 billion commits in a single week. To put this figure into perspective, that volume represents a 400% increase compared to the same period just one year prior. In fact, that single week of activity surpassed the total number of commits GitHub processed throughout the entirety of 2025. While these numbers signal a new era of velocity, they also raise a poignant question for the global developer community: as we generate more code than ever before, do we actually feel 400% more productive?
For many, the reality is more nuanced. While artificial intelligence has undoubtedly accelerated the mechanical act of writing code, it has also introduced a paradox of "AI acceleration whiplash." A study by Faros AI highlights a sobering trend: as teams transition from low to high AI adoption, the time spent in the pull request review process has ballooned by 441%. This suggests that while AI tools have mastered the art of drafting syntax, the human-centric work surrounding software development—planning, architectural oversight, code review, and production investigation—has not kept pace. The challenge now is not just writing code faster, but effectively managing the entire software development lifecycle in an era where agents are becoming active participants.
Orchestrating the Planning Phase
The modern engineering workflow often suffers from fragmented context. Consider the typical scenario of planning a significant API change: the design requirements might exist in a centralized documentation tool, critical compatibility constraints could be buried in historical Slack conversations, and the rationale behind existing implementations might be trapped in a years-old pull request. Before a single line of code is written, a developer must bridge these silos, compare various technical approaches, and ensure that existing clients remain supported. What should be a straightforward planning exercise frequently devolves into hours of exhausting manual retrieval, cross-referencing, and intellectual fatigue.
By integrating GitHub Copilot into the planning stage, developers can consolidate this scattered information. Instead of treating planning as a manual search-and-rescue mission, AI agents can assist by aggregating relevant context, facilitating the evaluation of tradeoffs, and converting high-level decisions into structured implementation plans. This shift allows developers to focus their cognitive energy on architectural decisions and strategic outcomes rather than the drudgery of information gathering. By the time the implementation phase begins, the developer is not starting from a blank page but from a robust, reviewable plan with clearly defined acceptance criteria.
Building with Agentic Support
Translating a well-conceived plan into production-ready code is rarely a linear process. Real-world engineering is subject to constant interruption—a sudden meeting request, an urgent bug report from a colleague, or an unforeseen edge case identified during a design review. In such an environment, the ability to maintain progress across multiple tasks is essential. It is common for a developer to have an AI agent halfway through a complex refactor when they are forced to pivot, leaving them feeling as though they cannot be in two places at once.
Effective agentic engineering solves this by enabling tasks to progress independently, tethered to shared project knowledge rather than a single local workstation. Copilot allows developers to pick up their work seamlessly across different devices, ensuring that momentum is maintained even amidst the volatility of a busy workday. This approach enables developers to handle implementation details and emerging requirements without losing sight of the broader project goals. By empowering agents to handle routine aspects of the build, the developer retains the flexibility to focus on the high-level logic and complex problem-solving that demand human judgment. The result is a series of focused, high-quality changes ready for submission, rather than a disorganized rush to complete a task.
Refining the Review Process
Perhaps the most significant bottleneck in the modern development lifecycle is the review queue. It is all too common for a developer to submit a pull request labeled as a "small refactor," only to realize the scope has ballooned to include dozens of files, ranging from shared validation logic to formatting changes and extensive test suites. When these changes are presented without clarity, they become a nightmare for reviewers, who must sift through the noise to find the actual substance of the update. This is the 441% increase in review time manifesting in real-world practice.
The solution lies in optimizing the process from both ends. Developers can leverage AI to handle routine checks and pre-verification tasks before a human ever opens the diff, ensuring that the code submitted for review is clean, well-tested, and focused. By automating the mundane aspects of code quality, the pull request becomes a streamlined instrument for peer feedback. Reviewers can then spend their valuable time focused on the core intent of the changes, assessing architectural health, and identifying potential failure modes, rather than getting bogged down in formatting errors or redundant code.
Learning from Production Observations
The software development lifecycle does not conclude once a deployment is successful. The transition to the "Observe" phase is often the most stressful, as intermittent production issues can quickly turn a successful release into a crisis. When timeouts or customer-reported issues occur, developers often find themselves trapped in a reactive loop, toggling between various dashboards, log files, and commit histories to diagnose the root cause. The phrase "all checks passed" offers little comfort when a system is behaving unpredictably in the wild.
By integrating operational evidence and engineering context, Copilot can assist in bridging the gap between production behavior and source code. Instead of manually retracing the steps of an investigation, developers can use agents to synthesize logs, historical release data, and customer feedback. This allows for a more efficient diagnostic process, where the focus remains on deciding what needs to change rather than struggling to understand what occurred. Furthermore, this knowledge is fed back into the next planning cycle, ensuring that the team learns from the software people are actually using, thereby creating a continuous loop of improvement.
Where to Start
Adopting an agentic engineering workflow does not require a wholesale overhaul of a team’s processes overnight. The most effective approach is to identify a single point of frustration—whether it is the initial planning, the review process, or the post-deployment investigation—and deploy an agent to alleviate that specific friction. By starting small and expanding the use of agents across the development lifecycle, teams can slowly cultivate a more efficient, less stressful environment.
As these tools become more deeply embedded in the workflow, the goal is not to replace the human developer, but to augment their capabilities. When agents handle the retrieval of context, the routine aspects of building, the preliminary review, and the synthesis of production data, the developer is finally free to exercise the judgment that no AI can replicate. Only then will the massive increase in commit counts truly align with a commensurate increase in meaningful, sustainable human productivity. This methodology was explored in detail at GitHub Universe 2026, during the session "Agentic Engineering: Past the Pilot," highlighting that the future of development lies not in faster typing, but in smarter, more integrated workflows.

