PaperlayerView exact revision on arXiv

Source-linked AI summary

Agentic Much? Adoption of Coding Agents on GitHub

Romain Robbes, Théo Matricon, Thomas Degueule, Andre Hora, Stefano Zacchiroli

arXiv:2601.18341v2cs.SE

TL;DR

Coding-agent adoption is difficult to study because repository evidence is incomplete, yet agents leave enough traces to support large-scale measurement. Using validated heuristics across 128,018 GitHub projects, the paper estimates 22.20%–28.66% adoption and finds it rapid, broad, and increasing. The findings motivate further investigation while remaining bounded by open-source coverage and imperfect observability.

  • Problem

    Coding-agent adoption and practical use have been little studied, despite rapid emergence and repository traces that enable large-scale investigation.

  • Method

    The study applies validated heuristics to files, commits, pull requests, branches, and labels across open-source GitHub projects, analyzing adoption through multiple project and organizational lenses.

  • Results

    22.20%–28.66% of 128,018 GitHub projects show coding-agent traces as of February 21st, 2026, with adoption rapid, broad, and still increasing.

  • Takeaways & Limitations

    Coding-agent adoption spans project types, programming languages, organizations, and maturity levels, while a sizeable proportion of projects show consistent or pervasive use.

  • Takeaways & Limitations

    Repository-trace heuristics can under-estimate or over-estimate adoption, and findings from open-source GitHub projects may not generalize to industry use.

Abstract

from arXiv · show

In the first half of 2025, coding agents have emerged as a category of development tools that have very quickly transitioned to the practice. Unlike ''traditional'' code completion LLMs such as Copilot, agents like Cursor, Claude Code, or Codex operate with high degrees of autonomy, up to generating complete pull requests starting from a developer-provided task description. This new mode of operation is poised to change the landscape in an even larger way than code completion LLMs did, making the need to study their impact critical. Also, unlike traditional LLMs, coding agents tend to leave more explicit traces in software engineering artifacts, such as co-authoring commits or pull requests. We leverage these traces to present the first large-scale study (128,018 projects) of the adoption of coding agents on GitHub, finding an estimated adoption rate of 22.20%--28.66%, which is very high for a technology only a few months old--and increasing. We carry out an in-depth study of the adopters we identified, finding that adoption is broad: it spans the entire spectrum of project maturity; it includes established organizations; and it concerns diverse programming languages or project topics. At the commit level, we find that commits assisted by coding agents are larger than commits only authored by human developers, and have a large proportion of features and bug fixes. These findings highlight the need for further investigation into the practical use of coding agents.

1 Introduction

Coding agents differ from earlier completion-based assistants through greater task scope and autonomy, while leaving repository traces that enable large-scale adoption studies. This study finds rapid and broad adoption, with agent-assisted commits showing distinct characteristics and with important heuristic limitations.

  • Coding agents can operate from close supervision to nearly complete autonomy, including submitting complete pull requests for review.
  • Repository traces such as configuration files, acquired-knowledge summaries, and commit or pull-request metadata make large-scale adoption measurement possible.
  • 22.20% of 128,018 projects show estimated coding-agent adoption, with a high estimate of 28.66% as of February 21st, 2026.
  • Adoption spans project maturity, established organizations, programming languages, and project topics, while larger and more mature projects adopt in comparable proportions to smaller and less mature ones.
  • Agent-assisted commits are larger than human-only commits and contain substantial proportions of features and bug fixes.
  • The study notes that its heuristics may overcount or undercount adoption, motivating further discussion of limitations and future work.

2 Background

Coding agents repeatedly query an LLM with tool access, using feedback from their environment to complete developer-specified tasks. Their tools, context mechanisms, guidance files, and repository traces shape both operation and observability.

  • A coding agent is an LLM running in a loop with tool access to complete a given goal.
  • The agent loop queries the LLM, parses tool calls and completion, optionally requests permission, and feeds tool results into later interactions.
  • Some agents can commit changes or author pull requests and may insert co-authorship metadata, creating observable repository traces.
  • Tool access lets agents dynamically explore repositories and use compilation or tests to debug and refine proposed solutions.
  • Given a task, the agent explores the codebase, edits code, processes compiler feedback, and iterates until the task is completed or tests pass.
  • Developers can provide detailed instructions, feedback, and committed guidance files that encode project-specific knowledge for later iterations.

3 Related work

Prior work on coding assistants reports mixed productivity, quality, and usage findings, while emerging coding-agent studies examine user barriers, artifacts, traces, and autonomous interactions. This study contributes a larger, newer, project-level quantitative view of adoption across many agents and contexts.

  • Earlier coding-assistant studies: Controlled experiments on coding assistants report mixed productivity and quality outcomes, including faster completion alongside reduced quality or more task failures.
  • Earlier coding-assistant studies: Observation studies distinguish acceleration and exploration usage modes and show that evaluating AI suggestions can consume substantial developer time.
  • Earlier coding-assistant studies: Surveys, interviews, and telemetry identify successful use cases, validation barriers, trust, acceptance, and organizational code-generation rates.
  • Mining software artifacts: Repository studies have analyzed software-engineering task traces, artifact changes, and coding-agent pull requests, including sharp growth for several agents.
  • Coding-agent studies: User studies report barriers involving task delegation and project-specific knowledge, while autonomous-agent traces vary substantially across agents and outcomes.
  • This work: Compared with prior studies, this work analyzes about 130,000 repositories quantitatively, uses newer 2025–2026 data, and examines projects rather than only individual artifacts.
  • This work: The study detects dozens of agents and examines adoption by programming language, project type, organization, and time.

4 Methodology

The study mines open-source GitHub repositories with broad, validated heuristics for coding-agent traces and analyzes adoption through multiple artifact types and project characteristics. Validation finds few legitimate false positives, while hidden or disabled traces can cause undercounting.

  • The study uses GitHub repository data, an automated gathering pipeline, coding-agent heuristics, metrics, and research questions to analyze real-world adoption at scale.
  • Detecting agents is difficult because tools differ in interfaces, autonomy, and repository traces, including IDE integrations, command-line operation, and pull-request workflows.
  • The heuristic set covers files, authors, branches, and labels, using documented procedures to map agent names, inspect repositories, search GitHub, and cross-check patterns.
  • Users can hide AI-assisted commit traces by removing metadata or not adding files, causing those commits to be classified as human-authored.
  • The study excludes ambiguous CONVENTIONS.md evidence because its general project use creates a greater false-positive risk than the potential underestimation of Aider usage.
  • Validation samples of roughly 400 artifacts were independently checked and adjudicated by two authors for true-positive and false-positive status.
  • 0.5%–1% of evaluated cases were legitimate false positives overall, while borderline cases represented about 3%.

4.2 Analysis Pipeline

The analysis pipeline filters GitHub repositories, detects coding-agent traces through file, commit, and pull-request heuristics, and gathers project and artifact statistics. It combines automated extraction with sampling-based validation and analyzes both explicit and silent adopters.

  • Study period: The analysis emphasizes automation because coding-agent adoption is recent and rapidly evolving, using data from January 1, 2025 through February 21, 2026.The authors note that the study period may later be extended with updated data.
  • Data selection: The study filters repositories by excluding forks and requiring at least 5,000 lines of code, 100 commits, and recent activity.The initial dataset comes from repositories with at least 10 stars.
  • Data selection: 128,018 projects remain after pipeline failures and removal of approximately 500 non-representative dotfiles repositories.The pipeline began with 130,621 projects and lost approximately 1,500 unavailable or otherwise failed repositories.
  • Adoption detection: File-level adoption is detected by matching repository file lists and .gitignore files against compiled coding-agent heuristics.Repositories can be classified as adopters even when configuration files are excluded from version control.
  • Downstream analysis: The pipeline computes configuration-file histories and analyzes adopter and non-adopter repositories to identify both explicit and silent adopters.Per-file statistics include first-addition date, modification count, and latest-version size.
  • Adoption detection: Commit-level adoption is identified from commit messages, authorship metadata, changed files, and file-change statistics collected through historical repository clones.Pull requests are separately matched using branch and pull-request heuristics, with associated commits tagged as AI-assisted.

4.3 Metrics

The study measures coding-agent adoption at file, commit, and overall project levels, then characterizes projects, artifacts, languages, and adoption timing. It also categorizes projects by the share of commits assisted by agents.

  • Adoption metrics: Overall adoption is measured as the proportion of projects exhibiting file-level, commit-level, or combined adoption indicators.These metrics address the study’s first research question.
  • Project metrics: Project characteristics include age, commits, pull requests, issues, contributors, GitHub topics, ownership, and programming language.These variables support analyses of adopter characteristics and usage contexts.
  • File metrics: File adoption is summarized by configuration-file count, cumulative file size, and commits modifying those files.These statistics quantify how and when agent configuration enters projects.
  • Commit metrics: Commit-level statistics count added and deleted lines and the numbers of files added, modified, or removed.The same raw measures are extracted for AI-assisted and human-authored commits.
  • Timing metrics: Adoption date is the earliest commit adding an agent configuration file or matching an AI-assisted commit heuristic.Dates are computed for each agent and for the project overall.
  • Language classification: GitHub Linguist’s extension database classifies changed files by type and programming language without parsing file contents.Ambiguous extensions are resolved using the most popular language for that extension in the dataset.
  • Adoption intensity: The AI-assisted commit ratio equals AI-assisted commits divided by all AI-assisted and human-authored commits after adoption.Ratios are computed overall and separately by file type.
  • Adoption intensity: Projects are classified as Experimental below 1%, Limited Use at 1%–5%, Consistent Use at 5%–20%, and Pervasive above 20% AI-assisted commits.Projects with fewer than 10 post-adoption commits are filtered from selected category analyses.

4.4 Research questions

The paper organizes its empirical study around adoption prevalence, adopter characteristics, usage contexts, temporal and organizational patterns, and coding-agent contributions.

  • RQ1: Overall adoption: RQ1 asks for the estimated adoption of coding agents on GitHub using file- and commit-level adoption measures.The paper answers this question by analyzing overall adoption.
  • RQ2: Adopter characteristics: RQ2 asks which characteristics distinguish projects adopting coding agents, including size and age.The analysis uses distributions of commit-adoption metrics and basic project metrics.
  • RQ3: Usage contexts: RQ3 asks in which contexts coding agents are used, including programming languages and project types.Project type is represented through GitHub topics.
  • Additional analyses: The research-question framework also examines adoption across time and organizations and analyzes contributions authored or co-authored by coding agents.These dimensions extend adoption measurement beyond a single overall rate.

5 RQ1: estimation of overall adoption

The paper estimates coding-agent adoption using complementary file- and commit-level traces across 128,018 projects. File and commit signals overlap incompletely, producing an overall estimate between 22.20% and 28.66%, though the upper estimate is rough.

  • File-based adoption: 12.08% of 128,018 projects reference coding-agent files through visible files or .gitignore entries.The total combines 12,861 projects with detected files and 2,606 additional projects identified only through .gitignore references.
  • Commit-level adoption: 11.51% of 112,551 projects without file-level traces are identified as commit-level adopters.This percentage is similar to the file-level adoption percentage.
  • Signal overlap: File-level and commit-level heuristics overlap incompletely, with almost two thirds of visible file-level users detected by commit-level heuristics.The reverse mismatch also occurs: some file-level adopters are not detected through commits.
  • Overall estimates: 22.20% is the conservative overall adoption estimate obtained by summing file-level adopters with commit-level adopters found outside the file-level group.This scenario estimates approximately 28,418 adopting projects.
  • Overall estimates: 28.66% is the high adoption estimate after accounting for potentially silent adopters inferred from incomplete visibility of file-level and commit-level traces.The authors describe this estimate as a rough approximation because silent adopters are difficult to observe.
  • Interpretation: The authors estimate true adoption lies between 22% and 28% as of February 21, 2026, indicating rapid adoption of a recently established tool category.The estimate is bounded by conservative and high scenarios rather than directly observed for every project.

6 RQ2: Adoption and project characteristics

Coding-agent adoption spans project sizes and maturity levels, with higher file-level adoption among larger projects but lower commit-level intensity in more established projects. Repository evidence also indicates substantial usage, while commit-based estimates likely undercount actual activity.

  • File-level adoption: 52.0% of projects have one guidance file, while 85% have five files or fewer.Only 4.2% have more than 10 files and 3.9% have more than 20.
  • File-level adoption: 29.0% of projects have 101–250 guidance lines, while 12.4% exceed 1,000 lines.Only 5.1% have 10 lines or fewer, suggesting that most projects use more than minimal guidance.
  • Project characteristics: 15.22%–15.91% of the largest project-size deciles show file-level adoption, more than double the 6.94% rate in the smallest decile.Adoption also reaches 17.88% among projects with at least 68 contributors, 19.03% in the largest commit decile, and 20.45% in the highest issue decile.
  • Project characteristics: Younger projects have higher file-level adoption, but adoption remains nearly 8% among old projects.After excluding projects younger than one year, higher adoption for larger metric values and decreasing adoption with age persist.
  • Caveats: Commit-level adoption is likely underestimated because agents may not sign commits, may have signing disabled, or may be used while developers commit manually.These behaviors can produce an observed zero ratio even when agents were used.
  • Commit-level adoption: 26.73% of projects with file adoption markers have a zero AI-assisted commit ratio, while 17.56% are classified as pervasive users.The analysis excludes projects detected solely through .gitignore from file-level distributions and filters zero-ratio projects from subsequent commit-ratio comparisons.
  • Commit-level adoption: 23.97% of projects with non-zero commit adoption have more than one in five commits AI-assisted.Among these projects, 5.25% have majority-AI-assisted commits and 3.09% have at least three quarters AI-assisted.
  • Commit-level adoption: Larger or more established projects tend to have smaller ratios of AI-assisted commits across project-metric deciles.This contrasts with file-level adoption, which generally increases with project size and activity.

7 RQ3: contexts of use of coding agents

Coding-agent adoption spans organizations, project topics, and programming languages, although its prevalence varies by context. File-level adoption is especially high in some organizations and topics, while commit-level adoption is more uniformly distributed.

  • 7.1 Adoption in specific organizations: 17.21% file-level adoption occurred across repositories in the top twenty organizations, versus 12.08% overall.This represents a relative increase of approximately 42% among repositories of top organizations.
  • 7.1 Adoption in specific organizations: 25.80% file-level adoption made Microsoft one of the highest-adopting organizations, while HashiCorp had the lowest at 2.27%.Rust, Kubernetes, and Symphony also remained below average, at 3.85%, 4.00%, and 4.08%, respectively.
  • 7.2.1 Overall adoption by topic: Around 22% average topic adoption was scattered widely, with few topics showing extremely low adoption.Minecraft, system, and network-programming topics were below average, while web, cloud, automation, database, open-source, dotnet, and vscode topics ranged from average to approximately 35%.
  • 7.2.1 Overall adoption by topic: 35–80% adoption appeared for topics including agents, MCP, AI, LLM, ChatGPT, OpenAI, Angular, Next.js, and Ethereum.Some high-adoption topics may reflect projects developing agents and using them for agent development; explaining these patterns is left to future work.
  • 7.2.2 Commit-level adoption by topic: 6.7% was the overall median commit ratio across topic-level commit adopters, with adoption more homogeneous across topics than at the file level.The paper reports little correlation between topic-based file-level adoption and commit ratio, including no higher commit ratio for AI, LLM, or agent topics.
  • 7.3 Adoption by programming language: 7.8% was the overall median commit ratio across programming-language adopters, and most languages differed by no more than ±10%.Adoption extended beyond popular languages to Dart, Swift, Kotlin, and Julia, while GraphQL, SCSS, Svelte, and Elixir trailed; most projects had ratios below 20%, but some reached 40–100%.

8 RQ4: evolution of adoption over time, and tool-specific adoption

Coding-agent adoption increased rapidly from early 2025, with several acceleration points and renewed growth in early 2026. A small group of tools accounted for most adoption, while substantial co-adoption occurred across projects and organizations followed varied uptake profiles.

  • 8.1 Evolution of adoption over time: Late February 2025 marked faster adoption growth, followed by the fastest rate from mid-May 2025 after multiple agents were released.Adoption appeared to slow from September to December 2025 but accelerated sharply again at the start of 2026.
  • 8.2 Tool-specific adoption: 42,060 tools were adopted across 26,883 projects, indicating that some projects used multiple coding agents.The tool-specific analysis tracked 54 tools and separated the most popular tools from less frequently adopted tools.
  • 8.2 Tool-specific adoption: More than 80% of overall adoption came from the top five tools, while Claude and Copilot together accounted for more than half.Generic usage is associated mainly with Codex but cannot be attributed to Codex with certainty because AGENTS.md is becoming a standardized guidance-file format.
  • 8.2 Tool-specific adoption: Approximately 6,000 projects were estimated to adopt Codex, placing it third behind Claude and Copilot.This estimate assumes approximately 90% of the relevant remainder used Codex and is explicitly described as very rough.
  • 8.3 Tool co-adoption: Two thirds of projects used a single tool, while the remaining third used multiple tools.Among 26,883 projects, 5,570 used two tools, 2,072 used three, and 1,467 used four or more.
  • 8.4 Adoption evolution in organizations: Organizations showed distinct adoption profiles, ranging from rapid or nearly overnight uptake to adoption by waves or more regular growth.Several organizations also showed the broader acceleration patterns observed in February–March, May–July, and late 2025 or early 2026.
  • 8.4 Adoption evolution in organizations: Microsoft was the earliest and largest overall adopter among top organizations, with adoption present as early as January 2025.Figure 10 reports 619 adoptions for Microsoft across the top organizations.

9 RQ5: Size of AI contributions

AI-assisted commits were larger than human-authored commits across lines added, lines deleted, and files involved. They were also more concentrated at the large end of the size distributions, suggesting greater churn and more frequent non-local changes.

  • 9 Size of AI contributions: 31 median added lines characterized AI-assisted commits, compared with 11 for human contributions and 4 for bots.The AI-assisted median was triple the human median and closer to the human third quartile of 41 lines.
  • 9 Size of AI contributions: 7 median deleted lines occurred in AI-assisted commits, compared with 5 for human commits and 3 for bots.At the file level, AI-assisted and human commits both involved a median of two files, versus one for bots.
  • 9 Size of AI contributions: AI-assisted commits adding 1–5 lines were 36% less frequent, while commits adding more than 1,000 lines were almost twice as frequent.The size-category comparison shows the strongest differences at the distribution’s edges.
  • 9 Size of AI contributions: AI-assisted commits with 1–5 deleted lines were 12% less frequent, while those with thousands of deleted lines were 36% more frequent.Single-file AI-assisted commits were nearly 15% less frequent, whereas commits involving more than 20 files were 30% more frequent.
  • 9 Size of AI contributions: AI-assisted commits tended to add and delete more code across more files than human-authored commits, raising questions about sustainability over time.The paper connects these patterns with increased churn and more frequent non-local changes.

10 RQ6: Types of commits authored by coding agents

The study examines what kinds of software-development work coding agents contribute to, using commit-level analysis. Agent commits span all categories, but feature and bug-fix work dominates compared with human commits.

  • Protocol: The analysis samples 790 of 90,321 Claude-authored commits and classifies them using Conventional Commits prefixes or independent manual review.Of the 790 commits, 513 conform to the convention and 277 are manually reviewed.
  • Results: Two thirds of analyzed Claude Code commits are feat or fix, while chore commits account for 7.1%.The comparison uses a random sample of 790 Claude Code commits and a human-authored baseline from prior work.
  • Results: Feature-introducing commits are about twice as common for agents as for humans.The remaining commit-category percentages differ by two percent or less between the agent and human samples.
  • Results: Agent-assisted commits can be large across categories, including tests, refactorings, and documentation.Examples include 488 added lines for tests, 14 files changed with +912/-19 lines for refactoring, and 180 documentation lines.
  • RQ6: Types of commits authored by coding agents: Coding agents contribute across the full set of software-development task categories defined by Conventional Commits.The analysis uses commit messages and manual review to classify agent contributions.

11 Discussion

The discussion emphasizes that adoption estimates and contribution measures are constrained by incomplete observability, heuristic detection, dataset choices, and open-source scope. It also cautions that larger agent-assisted commits do not establish higher productivity.

  • Discussion: The authors conclude that their heuristics are more likely to underestimate than overestimate coding-agent adoption.They discuss both directions of error and state that underestimation is more likely.
  • Generalizability of findings: The study analyzes high-level project characteristics but does not extend comparable analyses to the other research questions.The restriction was made to avoid substantially lengthening the paper.
  • Generalizability of findings: The findings may not translate well to industry because coding-agent use and costs can differ from open-source software.The authors think industry use might be higher than open-source use.
  • Extent of agent involvement: Agent involvement cannot be determined precisely from repository artifacts, because observed commits and pull requests may include substantial developer work.For unsigned agents, the study may attribute all commits in a pull request to the agent even when follow-up work was performed by the developer.
  • Size is not everything: Larger AI-assisted commits should not be interpreted as greater productivity because churn and reverts were not analyzed.The authors explicitly leave productivity assessment to future work.
  • Absence of evidence: Projects without detected traces may still use coding agents, since agents and developer workflows differ in whether activity appears in files, commits, or pull requests.Examples include unsigned commits, cloud-based workflows, and configuration stored outside the project repository.

12 Conclusion

This study measures coding-agent adoption across a large GitHub-project dataset and examines its breadth, growth, and commit-level contributions. It finds rapid, broad adoption and larger agent-attributed contributions, motivating further study for practice and research.

  • Conclusion: Between 22.20% and 28.66% of 128,018 GitHub projects show traces of coding-agent use as of February 21st, 2026.Adoption occurred mainly from March to October 2025 and was still increasing.
  • Conclusion: Adoption is broad across project types, programming languages, organizations, and levels of project maturity.The study also identifies consistent, pervasive, and extreme-use projects.
  • Conclusion: Coding agents are used to implement features and bug fixes through contributions larger than those authored by humans.This conclusion summarizes the commit-level analysis.
  • Implications: The findings have implications for software-development practice and motivate researchers to study coding-agent use during this rapid transition.The authors identify advice for practitioners as a research need.

A Selected coding agents

This section identifies the coding agents included in the study and directs readers to their URLs in Table 9.

  • Table 9 lists the coding agents included in this study.
  • Readers can use Table 9 to review the study’s selected coding-agent set.
  • The table provides URLs for the coding agents included in the study.
Loading 2601.18341v2…