GitHub recorded more than 1.2 billion commits in a single week this October. That figure is over 400% higher than the total volume seen during the same period last year. You might be writing more code than before, but ask yourself if you feel four times as productive.
Software development involves more than just crafting good prompts. As AI speeds up implementation, pressure shifts to other areas. A study by Faros AI found that pull requests spent 441% longer in review when teams moved from low to high AI adoption.
Developers gather requirements, steer implementation, review changes, and evaluate test results before investigating production issues. Agents can help you work more efficiently across these stages: Plan, Build, Verify, and Observe. We will walk through an effective agentic engineering workflow on GitHub.
Plan: Get everyone and every agent on the same page
This sounds familiar. You are planning an API change. The design sits in one tool, a compatibility requirement is buried in Slack, and an old pull request explains the current implementation. Before writing a useful plan, you must connect those details, compare approaches, and agree on how existing clients will continue working. What looks like a straightforward planning task becomes hours of searching, cross-checking, and chasing answers. You are 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 have already set yourself and your agents up to implement your plan.
Build: Move more than one task forward at a time
You are 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 minutes. Then someone in the meeting points out an edge case the implementation needs to handle. Everyone needs something from you at once. You would like to keep making progress, but you cannot 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 is 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 do not 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 have all landed in a good spot. So you open a pull request labelled “small refactor.” It changes 47 files. You wanted feedback on shared validation logic, but it is 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 organisation’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 dependencies against your organisation’s requirements.
What it means
These features shift the burden from the individual developer to the workflow. You do not need to manually gather every piece of context or wait for a human to check every standard. The system handles the routine checks and keeps your work moving even when you step away. This allows you to focus on the decisions that actually require your attention.
