Write a post
Technology·12 min read

GitHub's Octoverse says agents now start more than 40% of pull requests

GitHub's annual report describes a sharp rise in agent-assisted development, alongside 17.9 billion code pushes.

GitHub's Octoverse says agents now start more than 40% of pull requests

GitHub's 2026 Octoverse report says developers pushed code 17.9 billion times during its October 2025–September 2026 reporting year. The company also reports that, by September, more than 40% of pull requests were started with an agent, up from 17% in March.

The figures describe activity on GitHub, not proof that agent-written code is better. A pull request can start with an agent and still require extensive human review. The report also says 61% of Copilot users who manually chose models used more than one model in September.

For teams, the practical question is shifting from whether agents can produce code to how the work is reviewed, tested, and maintained. Has an agent made your review queue shorter or just moved the effort?

What the activity figures measure

GitHub’s Octoverse covers activity during its October 2025 to September 2026 reporting year. It reports 17.9 billion code pushes and says agents initiated more than 40% of pull requests by September, versus 17% in March. “Started with an agent” is a workflow classification; it does not say every line of a pull request was generated by AI, or that a human never edited the result. The change in share is still striking because it shows agents moving from experiments into regular repository work.

Another reported figure is that 61% of Copilot users who manually selected models used more than one model in September. That helps explain why vendors now emphasize routing between models. It does not tell us how frequently those users changed models, what tasks they performed, or whether the choice improved outcomes. Public activity data is useful for describing adoption, but quality and security need separate measures.

At a glance

MeasureReported value
Code pushes17.9 billion in the reporting year
Pull requests started with agentsOver 40% by September 2026
Earlier agent-started share17% in March 2026

What to watch next

For a software team, the next metric is not simply more pull requests. Track review time, escaped defects, revert rates and maintainability after merge. If AI produces more proposals than reviewers can scrutinize, throughput at the first step may hide a slower final delivery.

The headline number needs its denominator

GitHub’s report says agents started more than 40% of pull requests by September 2026, up from 17% in March. That describes the share of pull requests on GitHub under the report’s definition, not the share of all software code written worldwide. It also does not mean that an agent completed every stage of those requests. A human might have prompted the work, revised the patch, run tests and decided whether to merge. The denominator matters because platform activity reflects the communities and organizations that use GitHub. The direction of change is still meaningful: agent participation has moved from a niche workflow toward a routine starting point for many contributors. To understand what that means for software quality, however, we need measures beyond the number of proposals created.

Why pull request creation is only the first step

A pull request is a proposal to change a repository. Its value depends on whether the change is correct, understandable and worth maintaining. An agent can lower the effort needed to draft a proposal, potentially allowing a developer to try a fix that would otherwise wait. It can also increase the number of low-quality proposals a maintainer must triage. Counting agent-started requests without reporting acceptance, revision and revert rates leaves that question open. A useful team dashboard would track how long a proposal spends in review, what tests it passes, how often reviewers ask for changes and whether the result stays in production. Some of this information is hard to interpret because difficult human-written changes also need more review. The point is to match a metric to the actual objective: reliable changes delivered, not drafts generated.

The human role shifts rather than disappears

As drafting becomes easier, deciding what should be built and verifying the result become more visible parts of engineering. A developer still needs to understand the problem, choose an acceptable design, give the agent relevant context and inspect the output. Maintainers may spend more time explaining repository conventions in machine-readable form so an agent can follow them. That investment can help human contributors too, if it produces clearer tests and documentation. The risk is that the person approving a change has less familiarity with the code than the system that generated it. A review process should force enough understanding to own the result. If a change cannot be explained by its author or reviewer, faster creation is not an unqualified improvement.

How to read 17.9 billion pushes

GitHub also reports 17.9 billion code pushes during its October 2025 to September 2026 reporting year. A push is an event that sends commits to a remote repository; it is not the same as a feature shipped, a bug fixed or a person contributing. A single task can involve multiple pushes, and automated workflows can contribute to activity. The number is useful as a picture of GitHub’s scale and the volume of repository work moving through the platform. It is less useful as a standalone productivity score. Comparing it with earlier years may reveal activity growth, but a careful analysis would account for changes in the number of repositories, developers and automated tools. The agent statistic should be interpreted with the same care: it signals adoption while leaving quality and causality to be studied separately.

Model choice is becoming a workflow

The report says 61% of Copilot users who manually chose models used more than one model in September. This is a specific group: it excludes users who did not manually select a model, and it does not tell us how often each person switched. Still, it supports a broader observation that developers are learning to match tools to tasks. One model may be preferred for quick completion, another for a long analysis or complex refactor. Vendors are responding with routing systems that attempt to make that choice automatically. For teams, this adds another layer to evaluate. A change in the model menu can affect output quality, cost or data handling without changing the repository’s source code. Recording model policies and usage can make experiments more interpretable.

The maintainers’ perspective

Open-source maintainers may experience agent adoption differently from employees inside a company. A company can set internal policies, require test coverage and train contributors on conventions. A public repository may receive proposals from strangers whose agents generated code without enough project context. Maintainers then absorb the review cost. The best contribution is one that identifies a real issue, respects the project’s design and provides evidence that the proposed fix works. An agent can help prepare that contribution, but it should not be used to flood projects with speculative pull requests. Clear contribution guidelines, reproducible bug reports and scoped changes remain valuable. The popularity of agents could make those norms more important, not less.

A better scorecard for organizations

An organization considering more agent use should begin with a baseline. How long do small changes take from issue to merge? What proportion of changes require rework? How many defects reach users? What is the burden on reviewers? Then introduce agents on a selected class of tasks and compare outcomes. Include the cost of subscriptions, model calls and human oversight. Avoid measuring only lines of code, which can reward unnecessary complexity. A good result might be a smaller patch with a better test, or a faster diagnosis that leads to no code change at all. The Octoverse figures justify asking these questions at scale; they do not answer them for a particular team.

Quality can be easy to obscure

Agent-generated changes can look polished. They may include neat explanations, tests and documentation even when the underlying assumption is wrong. Reviewers should check whether a test actually fails before the fix and passes after it, and whether it covers the user’s problem rather than the agent’s preferred path. Security checks should cover dependencies and permission changes as well as syntax. For large changes, separate reviewable steps reduce the chance that a hidden error rides along with useful code. These practices are not unique to AI; they are ordinary engineering discipline applied to a faster source of proposals. The risk rises when the volume of proposals exceeds the team’s ability to verify them.

What the report establishes

GitHub’s data establishes that its platform saw very high development activity and a sharp rise in agent-started pull requests over the period it measured. It supports the claim that AI agents are becoming a mainstream part of work on GitHub. It does not establish that agents write better code, that developers are being replaced, or that all teams should use the same workflow. The practical story is a change in where effort occurs. Creating a draft becomes cheaper; selection, review, integration and maintenance still determine whether software improves. Future reports will be more informative if they connect adoption figures to outcomes rather than only activity. Until then, organizations should treat the numbers as a signal to evaluate their own process carefully.

Why “started” is an important verb

A pull request may begin with an agent and end as a substantially human-revised change. Another may begin with a human and include agent-generated tests or documentation later. GitHub’s reported category captures one point in that process, not the full contribution of each participant. The difference matters if someone tries to use the number to claim that agents now write more than forty percent of all code. That would be a different measurement. A more complete study would describe agent participation at several stages: planning, code generation, test creation, review and maintenance. Such granularity would help teams understand where agents save time and where they add work. For now, the 40% share is a strong signal of initiation behavior on GitHub, with important limits on what can be concluded from it.

The effect on newer developers

Agents may lower the barrier to making a first contribution by explaining a codebase and drafting a modest fix. They may also let a beginner bypass the learning that comes from tracing a problem and understanding why a change works. A healthy workflow uses the generated patch as material to study and test. The contributor should be able to explain the changed behavior and respond to review. Maintainers can help by asking for concise evidence rather than trying to guess whether a tool was used. The issue is ownership of the result. If an agent allows more people to participate while strengthening their understanding, it is a positive change. If it produces more unexplained code that others must maintain, the apparent productivity gain is being transferred to reviewers.

Long-term signals to seek

Future platform reports could tell a richer story by following cohorts of changes beyond the moment a pull request opens. How often are agent-started requests merged? How long do they remain in review? Are they reverted at a different rate from comparable human-started work? Do maintainers report a change in the quality of incoming contributions? Care is required because task difficulty and repository policies differ, but the questions are answerable with careful study. The current Octoverse numbers make those investigations urgent. For an individual team, the best approach is to collect its own baseline and treat agent adoption as an experiment in how work flows from idea to stable software. More activity is a starting observation; better outcomes are the goal.

The story behind the trend line

The acceleration from 17% to more than 40% in a few months is a striking change in how proposals begin on GitHub. It is not a complete measure of how software is made. The next chapter belongs to teams and maintainers who decide whether agent-assisted work is easier to understand, test and keep. If adoption continues, contribution norms may need clearer expectations about evidence and review. The practical promise is more people able to turn an idea into a useful change. The practical burden is ensuring that each change still has an accountable owner and a sound explanation.

A final measure

A useful future report would also separate the effect of agents on small fixes, complex features and maintenance work. Those tasks place different demands on reviewers and produce different kinds of value.

Illustrative photograph: Informatics General programmer at terminal.jpg by Jonathan Schilling, CC BY-SA 4.0. The image does not depict the announced product or event.

Primary source: GitHub Octoverse 2026 (2026-10-28). Original Chirvy analysis updated October 30, 2026.

0 views

Chirvy Editor

Editorial account for Chirvy.

Replies 0

Log in to join the conversation.

It is quiet here. Be the first to reply.