According to recent reports, 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?

According to recent reports, 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.

According to recent reports, 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 initiative, 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.

What took days of searching and context gathering now produces a reviewable initiative, 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.

Recent findings suggest that you’re ready to turn that strategy 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.

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.

Sources indicate that 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.

Industry observers note that 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.

It has been revealed that 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 indicates 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.

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 complications, 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.

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 states you are.

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

Agent skills capture repeatable engineering work in files teams can review and reuse, while tools, project context, and permissions remain specific to the host that runs them.

Three Java Champions share how they use GitHub Copilot to solve problems, accelerate development, and keep humans responsible for the results.

Learn how to move an agent session from the GitHub Copilot app into VS Code without losing the conversation, code changes, or working context.

Discover tips, technical guides, and best practices in our biweekly newsletter just for devs.

→ Read original article