GitHub pushed a quiet but significant update to its Copilot usage metrics API on June 26, 2026, giving enterprise and organization admins the ability to see the total number of pull requests merged by users in each AI adoption phase. The change closes a critical gap in measuring AI’s impact on software development by moving beyond suggestions and acceptance rates to actual code that ships.
For engineering leaders who have been asking for hard evidence that Copilot is accelerating delivery—not just making developers feel more productive—this metric provides a direct link between AI usage intensity and the output that matters most: merged pull requests.
The Evolution of GitHub Copilot Metrics
GitHub first rolled out Copilot usage metrics in late 2024 as part of its push to give enterprises visibility into how the AI coding tool was being adopted. The initial dashboard offered basics like the number of active users, suggestions shown, and acceptance rates. Over time, GitHub added more granular data—lines of code accepted, active days, and breakdowns by language and editor.
In early 2026, GitHub introduced the concept of AI adoption phases, categorizing developers into four distinct stages based on their Copilot usage patterns: Not yet started, Evaluating, Adopting, and Scaling. This allowed organizations to segment their engineering workforce and track how individuals progress from never having used Copilot to integrating it deeply into their daily workflow.
Despite that, the metrics remained largely activity-based. Did a developer accept a suggestion? How many lines? While useful, these numbers didn’t answer the fundamental business question: Did that AI assistance lead to working code being merged into production?
AI Adoption Phases: A Quick Refresher
Before diving into the new metric, it’s worth recalling what these phases mean. GitHub automatically assigns each Copilot-licensed user to one of four buckets based on their last 28 days of activity:
- Not yet started: The user has been assigned a Copilot seat but has never accepted a suggestion.
- Evaluating: The user has accepted at least one suggestion but hasn’t yet reached a threshold that indicates regular use.
- Adopting: The user is using Copilot consistently, accepting multiple suggestions per day on average.
- Scaling: The user has integrated Copilot deeply, with high suggestion acceptance and frequent daily usage.
These phases are not manual labels; they’re calculated dynamically. So when an admin views the Copilot metrics dashboard or calls the API, they see a distribution of their developers across these categories. Previously, the API returned only the count of users in each phase and aggregate activity metrics like accepted suggestions. Now it returns something far more concrete.
What’s New: Total Merged PRs by Phase
As of the June 26, 2026 update, the Copilot usage metrics API (for both enterprise and organization endpoints) includes a new field called total_merged_prs within each phase breakdown. The response now looks conceptually like this:
{
"adoption_phases": [
{
"phase": "scaling",
"user_count": 42,
"total_merged_prs": 186
},
{
"phase": "adopting",
"user_count": 103,
"total_merged_prs": 294
},
{
"phase": "evaluating",
"user_count": 67,
"total_merged_prs": 83
},
{
"phase": "not_yet_started",
"user_count": 88,
"total_merged_prs": 51
}
]
}
The total_merged_prs value represents the number of pull requests merged by users in that phase during the selected time window (the API supports a from and to date filter). Importantly, it counts only merged PRs—not opened, closed, or draft PRs—so it reflects code that passed review and became part of the codebase.
This addition is fully backward compatible. Organizations already using the metrics API can simply update their data transformation logic to surface the new field. GitHub’s official documentation and API previews had been hinting at this for weeks, with the changelog confirming the general availability on June 26.
Why Merged PRs Are the Metric That Matters
For years, engineering teams have struggled to measure developer productivity without resorting to vanity metrics like lines of code. Pull requests merged is a more meaningful proxy for output, especially when combined with context about the type of work and code quality. By tying this metric to AI adoption phases, GitHub is giving organizations a way to quantify the bottom-line impact of Copilot.
Consider the scenarios this enables:
- ROI calculation: If developers in the Scaling phase merge significantly more PRs per person than those in Evaluating, an organization can estimate the productivity uplift from moving more devs into higher adoption phases and compare that to per-seat licensing costs.
- Bottleneck identification: If the Not Yet Started group shows a high merged PR count despite not using AI, it may indicate teams that are productive without AI—or it may suggest manual processes that AI could accelerate further. Either way, leaders can drill in.
- Adoption coaching: Engineering managers can spot teams where high adoption hasn’t translated into higher merged PR rates, possibly signaling that AI suggestions are being used but not effectively leading to completed work.
Most importantly, it shifts the conversation from “how many suggestions did we accept” to “how much working software did we deliver.” That’s a language executives and CFOs understand.
How to Access the New Data
The merged PR metric is available through the same REST API endpoints that serve Copilot usage metrics. For an enterprise, the endpoint is:
GET /enterprises/{enterprise}/copilot/usage
For an organization:
GET /orgs/{org}/copilot/usage
Both endpoints accept query parameters from and to (last 28 days by default) and require authentication with at least manage_billing:copilot scope or enterprise owner/admin permissions.
GitHub’s documentation emphasizes that the data may have a latency of up to 24 hours and that merged PR metrics are only available for the default branch and for repositories that were active during the selected window. Private repositories and public repositories are included, as long as the Copilot seat is assigned.
Admins can also see the new metric in the web UI under Settings > Copilot > Usage, though the UI currently only shows a simplified view; for deep analysis, the API is recommended and can be piped into tools like Power BI, Tableau, or custom dashboards.
Early Reactions and Community Sentiment
While the update is only a day old, engineering leaders who had access to the metric during the preview period are already sharing their observations. On internal Slack channels and social media, the predominant reaction has been relief—finally, a Copilot metric that ties directly to delivery.
One common question is whether the metric could be gamed. Because merged PRs reflect code that passed review, teams that uncritically approve AI-generated code might see inflated numbers. GitHub’s data scientists acknowledged this in a blog post, noting that the company is exploring complementary quality indicators such as code churn and production incidents, but that merged PRs remain a strong signal of productivity when used in context.
Another concern: the metric aggregates all merged PRs regardless of size or complexity. A developer might merge many small PRs while another merges a single monolithic one. GitHub’s response is that this metric is designed for trend analysis across large populations, not for individual performance assessment, and that organizations should use it alongside other signals like lead time and deployment frequency.
Strategic Implications for DevOps Governance
This update isn’t just a nice-to-have for curious managers; it has real implications for how organizations govern their software delivery processes. By marrying AI adoption data with workflow outcomes, enterprises can build more sophisticated analytics that inform hiring, training, and tooling decisions.
For example, a company might set a baseline for each phase and track whether entering the Scaling phase correlates with a sustained increase in merged PRs. If it does, the case for expanding Copilot licenses becomes airtight. Conversely, if a team in the Adopting phase shows no improvement, leadership might investigate whether the team needs more training or faces obstacles unrelated to AI (e.g., slow review cycles).
This kind of analysis ties directly into the broader DevOps movement’s emphasis on metrics-driven improvement. Merging Copilot data with DORA metrics—deployment frequency, lead time for changes, mean time to recovery, and change failure rate—remains a manual integration today, but the new API field makes it far more feasible. Expect to see open-source projects and commercial tools quickly adding Copilot adoption phase filters to their DevOps dashboards.
The Bigger Picture: Outcome-Based AI Metrics
GitHub’s move reflects an industry-wide shift toward outcome-based analytics for AI coding tools. Competitors like GitLab Duo and JetBrains AI have also started exposing more than just suggestion counts, but GitHub’s extensive enterprise telemetry and the popularity of Copilot give it a distinct advantage.
Microsoft’s own research, published at internal summits, has long suggested that AI assistance can boost developer throughput by 55% or more on certain tasks. But those claims were based on controlled experiments, not real-world data from heterogenous teams. With merged PR metrics, customers can independently validate those gains—or challenge them.
It also puts pressure on other metrics to evolve. If GitHub tracks merged PRs, what’s next? The ideal state is a comprehensive “AI impact score” that combines pull request output, code review sentiment, test pass rates, and production health into a single view. Part of that vision may already be underway; GitHub’s public roadmap mentions deeper integration with Actions and Advanced Security analytics.
What This Means for Windows-Centric Development Teams
Although Copilot runs everywhere, a huge portion of its enterprise user base is on Windows, using Visual Studio and VS Code. For Windows developers building .NET, C++, or Azure services, Copilot’s suggestions are deeply integrated into local workflows. Being able to tie those desktop-level AI interactions to team-level pull request outcomes brings closed-loop visibility that has been missing.
Windows shops that have standardized on Azure DevOps for repository management, however, will need to note that the merged PR metric is drawn from GitHub repositories. Organizations using GitHub Enterprise Cloud with AAD/Entra ID sync can bridge that gap, but those still running on-premises Azure DevOps Server won’t see this data without an external integration. GitHub has indicated that similar metrics for Azure DevOps-connected repositories are “under consideration,” but no timeline has been provided.
Practical Steps for Teams to Get Started
If your organization already uses Copilot and has admin access to the usage API, here’s a quick checklist to start leveraging the new metric:
- Update your API client: Add parsing for the
total_merged_prsfield in the response schema. - Choose a time window that aligns with your sprint cycles: The
from/toparameters let you match metrics to agile cadences. - Correlate with other signals: Combine merged PR data with lead time, cyclomatic complexity, or even team satisfaction surveys to build a multidimensional view.
- Set baselines per phase: Use historical data to understand what “normal” looks like, then monitor for deviations.
- Review with teams, not at them: Share the data with squads in retrospective-like forums to identify if AI is truly accelerating them or if process hurdles remain.
GitHub has published a sample Jupyter notebook that demonstrates how to pull and visualize this data, available in the github/copilot-metrics repository.
Potential Pitfalls and Ethical Considerations
No metric is perfect, and merged PRs can be misleading if interpreted simplistically. A rise in merged PRs might result from developers breaking work into smaller, less meaningful chunks—a practice sometimes called “PR farming.” Without concurrency metrics or quality checks, an organization could celebrate a hollow victory.
Additionally, sharing phase-level PR data without proper anonymization could lead to unfair comparisons or even pressure on developers to accept more AI suggestions just to boost metrics. GitHub’s documentation advises aggregating data across teams rather than drilling down to individuals, but the API returns data at the user level when queried with sufficient permissions. Organizations must establish ethical guidelines for how this data is used, ideally in consultation with developer representatives.
Looking Ahead: GitHub’s Copilot Analytics Roadmap
Sources inside GitHub have hinted that this is just the first of several outcome-focused metrics coming this year. Expected additions include:
- AI-assisted vs. unassisted merge time: How much faster do PRs get merged when AI is involved?
- Reviewer workflow impact: Do PRs authored with heavy AI assistance require more or fewer reviewer comments?
- Incident correlation: Are merges from high-AI-usage users more or less likely to be associated with production rollbacks?
Each of these would add another layer of understanding about how AI truly affects software delivery. Combined with the existing acceptance metrics, they would give enterprises a 360-degree view of their AI investment.
Conclusion: A Measured Step Toward AI Accountability
The addition of total merged PRs by AI adoption phase may sound like a minor API tweak, but it represents a major philosophical shift. It acknowledges that the real value of an AI coding assistant isn’t how much code it generates but how much of that code actually survives review and reaches users.
For Windows-focused teams, DevOps leaders, and anyone accountable for software delivery outcomes, this metric finally provides the quantitative link between AI adoption and business results. As GitHub continues to build out its analytics, the pressure will mount on competitors to offer similar transparency—and on organizations to use these numbers wisely.
Starting today, the question isn’t just “How many developers are using Copilot?” It’s “How many more pull requests are they merging, and how does that scale with their AI adoption journey?” With the June 26 update, GitHub has given us the tool to answer that question.