Agentic Very Much! Adoption of Coding Agent in New GitHub Projects Romain Robbes, Théo Matricon, Thomas Degueule, Andre Hora, Stefano Zacchiroli
arXiv:2606.07448v1 [cs.SE] 5 Jun 2026
June 8, 2026 Abstract In previous work, we investigated the adoption of coding agents in GitHub projects, finding that it was very significant. This study follows this line of work, but analyses new projects, that were created after the previous study. In this new sample, we find that the adoption of coding agents is more than twice as high. We also find that the adoption is significantly more intensive, as the proportion of AI-assisted commits is sensibly higher, despite strong signs that we do not detect all of it.
1
Introduction and methodology reminder
This is a companion paper to our previous study on coding agent adoption in GitHub projects (the “Agentic Much?” paper [RMD+ 26a]). It uses the sames heuristics, and share the same perils [RMD+ 26b]. We refer to the original paper for details on the methodology, but give a brief summary: • We use the sampling tool of Dabic et al [DAB21], to select projects with at least 100 commits and 5,000 lines of code, that are not forks, and are created after the date of the initial study [RMD+ 26a] (29/08/2025). The sampling tool itself only monitors projects with at least 10 GitHub stars. We access the tool on 04/04/2025, and download a list of 13,000 such projects. • For each project, we retrieve its file list and gitignore file via the GitHub API. We use these to search for file-based heuristics [RMD+ 26b]. • We also retrieve its pull requests (starting in 01/01/2025, taking at most 10,000 PRs) to search for PR-based heuristics. • We do a partial clone from 01/01/2025 to 04/04/2025, to extract the commits from the main branch, and look for commit-based heuristics. Based on this data, we compute metrics on the adoption of these projects. In particular, we compute: • The number of files identified by file-based heuristics as containing agent traces. • The number of lines and changes in these files. • The number of PRs merged in the main branch, in order to more precisely map the commits. • the Ratio of AI-assisted commits over all human + AI-assisted commits, which we call from now on the Commit Ratio. • The ratio of commits is also computed for specific programming language. We also use metrics coming from the original dataset, notably, the number of lines of code in repositories, the number of commits, the number of issues, pull requests, and contributors. We also use the GitHub topics of the repositories.
1
We run the exact same analysis as in the “Agentic Much” paper, on a dataset of newer projects. We compare the results with the analysis on the same dataset of the “Agentic Much”. In the remainder of this paper, we refer to these results as the “older projects”. Note that at this time of writing, the results from the “Agentic Much” paper itself are from a run of the analysis on 21/02/2026; the results presented here are from a newer run of the analysis, in early April–the “Agentic Much” paper will be updated in due time.
2
RQ1: Estimation of Overall Adoption
We begin with overall statistics of tool adoption across the surveyed repositories. Table 1 compares the adoption of new projects with older projects. We measure adoption at the file level (identified by presence of files matching heuristics in the file list of the paper, or in the .gitignore file). We also measure it at the commit level (identified by matching author and co-authors with known agents, or via identifying pull requests authored by known agents). We can see several striking differences. Table 1: Overall adoption statistics. For each statistic, the middle rows show the subset of the data the adoption is measured in. Metric
File
File-level tool usage File-level use Ignored files (all) Ignored files (only) All file-level use
✓ – ✗
Commit-level tool usage Commit use (file level) Commit use (all files) Commit use, no files High Estimate Commit Users Adoption estimates Conservative Adoption Estimate High Estimate Overall Adoption
Ignored
Commit
Count
– ✓ ✓ ✓(either)
– – – –
6,169 4,149 1,511 7,680
– ✓(either) ✗ ✗ ✗ ✗
✓ ✓ ✓ ✓
4,741 5,624 1,510 ≈ 2,062
6,169 7,680 5,114 5,114
76.85% 73.23% 29.53%
– –
– –
9,190 ≈ 9,742
12,794 12,794
✓
– –
Out of
Percent
New projects 12,794 48.22% 12,794 32.43% 12,794 11.81% 12,794 60.03%
Count
Out of
Percent
Older projects 15,685 127,670 12.29% 6,409 127,670 5.02% 3,083 127,670 2.41% 18,768 127,670 14.70% 15,685 18,768 108,902 108,902
67.82% 64.66% 13.79%
29.53% 73.23%
10,637 12,135 15,015 ≈ 23,222
71.83% 76.15%
33,783 ≈ 41,990
127,670 127,670
26.46% 32.89%
13.79% 64.66%
• The first is that file-level adoption (“All file level use” row) is four times larger in the newest projects, than in the older projects. • Similarly, the amount of adopters detectable by searching for ignored files (“Ignored files (only)” row) is 4 to 5 times larger in newer projects, which is roughly in line with the increase in file-level adoption. • In contrast, the commit-only level adoption (“Commit use, no files” row) is a bit more than twice as large for new projects, so it is comparatively smaller than the increase in file-level adoption. • There is also a higher proportion of commit-level adoption among file users (“Commit use, all files” row), which goes from a bit less than two thirds, to a bit less than three quarters. • The overall adoption (“Conservative Adoption Estimate”) goes from a bit more than one quarter, to more than two thirds, which is a very significant increase. All in all, this points to two principal findings: in newer projects, the adoption is much more extensive than in older projects. There are also some signs that the adoption is a more “Explicit”, in newer projects, as the proportion of projects that lack some kind of adoption is, in relative terms, smaller in the newer projects. This effect is limited however.
2
3
RQ2: Adoption and Project Characteristics
We analyze the distribution of the various adoption metrics to understand the magnitude of adoption changes. We analyze adoption metrics characterizing both file-level adoption and commit-level adoption.
3.1
Distribution of adoption metrics Table 2: Binned distributions of file and commit level adoption metrics Metric
Bin 1
Bin 2
Bin 3
Bin 4
Bin 5
1
2-5
6-10
11-20
21+
Newer projects
37.2%
36.3%
9.9%
6.3%
10.4%
Older projects
Total Files
Distribution
Bin 6
Bin 7
1001+
49.1%
33.5%
8.3%
4.8%
4.4%
Total Lines
0-10
11-50
51-100
101-250
251-500
501-1000
Newer projects
3.2%
9.2%
11.6%
22.9%
18.8%
13.0%
21.2%
Older projects
5.1%
13.3%
15.3%
28.9%
15.6%
9.4%
12.4%
Total Changes
1
2-5
6-10
11-20
21+
Newer projects
8.3%
22.1%
16.7%
18.2%
34.6%
Older projects
20.7%
35.6%
16.8%
12.2%
14.8%
Adoption Ratio
None
Experimental
Limited
Consistent
Pervasive
Newer projects
23.0%
6.8%
13.4%
15.6%
41.2%
Older projects
31.5%
6.9%
17.9%
22.6%
21.1%
Table 2 shows the distribution of the adoption metrics we measure for each type of projects, using the bins we defined in the analysis. For comparison, the rows representing the metrics of older projects have a gray background. For the commit ratio, we define the bins as follow: • “None”: there are no AI-assisted commits that we could identify. • “Experimental”: there are less than 1% of AI-assisted commits we could identify. • “Limited”: the AI-assisted commit ratio is between 1 and 5%. • “Consistent”: the AI-assisted commit ratio is between 5 and 20%. • “Pervasive”: the AI-assisted commit ratio is more than 20%. Based on the data, we can make the following observations: • In terms of number of files, we see a marked tendency for the newer projects to have more files than the older: the smallest bin (just one file) is still the largest one, but is smaller in the newer projects. Conversely, the largest bins are higher. In particular, the proportion of projects with more than 20 agent configuration or guidance files is more than twice as large in newer projects. • For total lines, we see a similar behavior. The first four bins (lines of code less than 250 lines) are lower in newer projects. On the other hand, the categories with more than 250 lines are higher, with the highest (1000+ lines) showing the largest difference: it is almost twice as large for newer projects; indeed, the largest bin is also the second most common. • In terms of changes to agent configuration files, we see an even bigger difference. The largest bin for the older projects is the one grouping 2 to 5 changes. On the other hand, for the newer projects, the largest bin is the one with the most extreme values, covering projects with more than 20 commits changing agent configuration files. This bin is more than twice as common for newest projects, and covers more than 1/3rd of the newest projects. 3
• Finally, the AI-assisted commit ratio follows a similar trend. The lowest bin (“None”) is smaller in newest projects, while the highest bin (“Pervasive”) is almost twice as more common in newer projects, and is by far the most common in the newest projects. This bin is covers more than 40% of all newest projects. To get a more precise view of the metrics, Figure 1 and Figure 2 show the distribution of the metrics of both types of project, without pre-defined bins. The Y axes differ, but the X axes are aligned. The graphs show a similar trend as the bin-level analysis, but for code changes and commit ratio, there is some interesting nuances. • The shape of the curves is very different for the number of changes, where we clearly see that the relative proportion of projects with higher number of changes is clearly larger in the newest projects. • for commit ratio, we see a completely different behavior in the distribution of the “pervasive” category. “Pervasive” adopters are both more common, and also show significantly more extreme values. For older projects, there is a tendency for the curve to decrease: large commit ratios are very uncommon. For newer projects, the curve is flat, and even rises at the end (projects with more than 80% of AI assisted commits). The proportion of extreme adopters of coding agents is thus much higher in newer projects. • In both cases (older and newer projects), there is a high proportion of projects with a commit ratio of 0, raising questions as to whether these projects have no AI activity, or rather hidden AI activity. 1200
400
600
1000
800
350
500
300
300
400
200
200
100
600
250
Count
600
Count
400
Count
Count
800
200
100
0
1
10
100
Files (log scale)
1K
0
10K
400
150 200
50 1
10
100
1K
10K
100K
Lines of Code (log scale)
1M
0
10M
1
10
100
1K
Code Changes (log scale)
10K
0
100K
0
20
40
60
80
100
40
60
80
100
Commit Ratio
Figure 1: Distribution of adoption metrics for newer projects
3000
1400 1200
1000
1000
600
800
1000
600
400
400
200
200
500
500 0
1500
800
Count
Count
Count
1500
2000
1200
1000 2000
Count
2500
1
10
100
Files (log scale)
1K
10K
0
1
10
100
1K
10K
100K
Lines of Code (log scale)
1M
0
10M
1
10
100
1K
Code Changes (log scale)
10K
100K
0
0
20
Commit Ratio
Figure 2: Distribution of adoption metrics for older projects
3.2
File-level adoption and project metrics
Table 3 shows the distribution of file-level adoption over project metrics, for both newer projects and older projects. The rows of older projects have a gray background. In each case, we split the distribution in deciles of the metric of interest, and we compute the adoption for the specific decile. We focus on two aspects: the evolution of the adoption over deciles, and the differences in decile values between older and newer projects. Particularly, we expect older projects to be larger in all metrics, and we discuss the differences with this in mind. We do not compare adoption rates between both kinds of projects, as we did that globally in the previous section. 4
Table 3: File adoption statistics versus project-level metrics, by deciles Metric
Aspect
Sparkline
D1
D2
D3
D4
D5
D6
D7
D8
D9
D10
Deciles
522
9.3K
15K
21K
28K
38K
52K
74K
113K
220K
File Deciles
32.11% 5.0K
45.90% 7.5K
52.15% 11K
53.28% 15K
62.31% 21K
68.02% 30K
68.12% 44K
74.28% 70K
75.29% 128K
68.83% 320K
File
18.52%
19.59%
19.64%
LOC
8.48%
10.11%
11.38%
12.18%
14.15%
15.41%
17.54%
Deciles
0.0
1.0
2.0
3.0
4.0
6.0
12
File Deciles
55.11% 0.0
62.18% 1.0
63.83% 3.0
64.37% 4.0
63.89% 6.0
59.15% 10
58.59% 14
21
34
68
File
11.10%
13.50%
13.80%
13.31%
13.35%
14.11%
14.56%
15.29%
16.23%
22.34%
Deciles
100
116
136
160
191
232
287
376
528
892
File Deciles
49.47% 100
51.76% 159
54.86% 233
57.19% 324
60.21% 446
60.91% 610
63.56% 849
63.45% 1.2K
70.17% 1.9K
69.09% 3.9K
File
18.76%
23.62%
Contributors
Commits
11.62%
11.72%
11.90%
12.18%
13.12%
13.59%
14.10%
16.40%
Deciles
0.0
1.0
2.0
5.0
9.0
17
32
71
File Deciles
56.73% 0.0
58.62% 3.0
57.98% 9.0
59.15% 19
59.38% 35
59.43% 60
63.80% 105
72.93% 195
458
File
Issues
11.49%
12.36%
12.86%
12.48%
13.40%
14.61%
15.52%
17.53%
25.39%
Deciles
0.0
1.0
3.0
7.0
16
28
46
77
150
File Deciles
48.16% 0.0
55.02% 1.0
58.18% 8.0
60.33% 22
58.92% 46
63.03% 85
65.67% 145
67.55% 244
78.19% 434
930
File
14.97%
16.38%
18.86%
30.68%
Pull Request
7.71%
9.34%
10.64%
12.20%
12.74%
13.60%
Deciles
0.0
0.1
0.2
0.3
0.4
0.5
File Deciles
71.60% 0.0
69.17% 1.1
58.84% 2.0
53.09% 2.9
48.56% 3.8
44.24% 4.8
5.8
7.1
8.7
11
File
29.03%
17.41%
15.91%
13.46%
12.84%
12.69%
12.42%
11.19%
10.88%
10.77%
Age (years)
Lines of code For lines of code, looking at the deciles, we see that newer projects are paradoxically larger in the first deciles (deciles two to eight); for instance, the boundary of decile 8 is 74,000 lines of code for newer projects, while it is only 70,000 lines of code for older projects. The trend reverts for deciles 9 and 10, where newer projects are smaller. The boundary of the largest decile is 320,000 lines of code for older projects, and 220,000 for newer projects. While the newer projects are smaller, they are not markedly smaller, especially since the oldest projects are a few months old at best. In terms of adoption, we see the same behavior for older and newer projects: larger projects have more adoption, with the exception of the slight drop of the last decile. Contributors Newer projects are overall significantly smaller in terms of contributors than the older projects, across most deciles. In terms of adoption, we see that the curve is slowly rising acrosss deciles for older projects, while it is more flat for newer projects (there is even a middle bump). Commits Newer projects have significantly less commits than older ones. Both the curve of older and newer projects rises with deciles,with the exception of the largest decile for commits.
5
Issues and Pull requests As with commits, issues and pull requests are less numerous for newer projects. In both cases the curve for issues rises, with a notable increase in the largest decile. The curves are more steep for pull requests, but the behaviour is similar. Age Newer projects are younger by construction. We see that even in this samples, the very youngest projects have a higher adoption than the marginally older ones.
3.3
Commit-level adoption and project-level metrics
Table 4 focus on the commit-level metric, the commit ratio. Once again, we compare the two categories of projects. Beyond the increase in intensity of adoption (higher commit ratios) of the newer projects, we can make several observations. Lines of code The relationship between commit ratio and lines of code is different. Notably, for older projects, the largest projects tended to have lower commit ratios. This is not the case anymore: the adoption across deciles is more or less flat when we look at the more intensive category, the ”pervasive” projects (more than 20% of commits detected as AI-assisted). Conversely, the lowest categories, ”experimental” and ”limited”, tend to rise for larger, older projects; this is not the case for newer projects. Contributors The relationship between commit ratio and lines of code is more similar in this category. Both older and newer projects have decreases in the ”none” category, and increases in the ”limited” and ”consistent” categories. For the ”pervasive” category, there is a regular drop for older projects, but the curse is more flat for newer projects, excep the last decile. Age For age, we once again see differences. For older projects, there is no clear trend. For newer projects, we see a decrease of intensity in the ”pervasive” category: the youngest of the newer projects have a more intense adoption. Table 4: Commit adoption across different project categories Category New Projects – All Files
N
None
Experimental
Limited
Consistent
Pervasive
6,884
19.00%
7.19%
14.82%
17.05%
41.94%
14,874
23.54%
8.47%
21.80%
26.06%
20.13%
by LOC by Contributors by Age Older Projects – All Files by LOC by Contributors by Age
Adoption categories and commit ratio Table 5 zooms in further on the commit ratio, exploring it on several categories of adopters. Overall, commit-level adoption is higher in projects that also show file-level adoption; it is lower in projects that have file-level adoption in .gitignore files; and it is lowest in projects that have no file-level adoption at all, only commits.
4
RQ3: Contexts of Use of Coding Agents
We examine repository properties and categorize adoption patterns across different dimensions. Figure 3 and Figure 4 contrast the commit ratio of projects by programming language, for newer and older projects. The red full line shows the median commit ratio for each set of projects. The dotted red lines show the upper and lower quartiles. The first thing we clearly see is that the overall commit ratio is much higher in the newer projects. The median is close to 30% vs 10% for older projects, while the upper quartile
6
Table 5: Commit adoption across different project categories Category
All Files with commits
Experimental
Limited
Consistent
Pervasive
Consistent
Pervasive
11.08%
Older projects 28.51% 34.08%
26.33%
53.31%
10.70%
27.95%
34.07%
27.28%
25.38%
43.27%
13.97%
32.78%
34.14%
19.11%
25.91%
35.99%
12.18%
34.55%
35.50%
17.76%
8.88%
Newer projects 18.29% 21.05%
51.78%
8.90%
17.52%
20.27%
8.77%
22.57%
9.49%
28.61%
Experimental
Limited
by LOC by Contributors by Age File level by LOC by Contributors by Age Files ignored only by LOC by Contributors by Age Commits only by LOC by Contributors by Age
is close to 25% for the older projects, whereas it is around 75% for the newer projects. In both cases, the newer projects seem to have triple the commit ratio. Comparing the programming languages is not straightforward, as both the amount of languages that cross the minimum threshold, and their size in terms of projects that use a programming language are different. Overall, there are more variations in commit ratio per programming language in the newer projects. One interesting comparison aspect is the number of projects per language in both sets, which shows some revealing differences. If we compare the percentage of adopters that use a given language in the newer projects with the ones in the older project, there are clear trends in terms of programming languages. Table 6 shows this data. Some languages are over-represented in newer projects. We see that in particular for shell scripting languages (Shell, Batchfile, Powershell), and some markup languages such as HTML. For programming languages, Rust is the most over-represented in newer projects. Other languages with sizeable usage that are over-represented include Javascript and its variants (Typescript, TSX), and Python. On the other hand, several established languages are under-represented in newer projects. These include systems languages such as C and C++ (newer projects seem to favor Rust), as well as general-purpose languages such as C#, Kotlin, or, to an even larger extent, Java. Figure 5 and Figure 6 contrast the commit ratio of projects by topics, for newer and older projects. We can clearly see a very different distribution of topics. While for the older projects, there is a broad distribution of topics, with some over-representation of machine learning and artifical intelligence topics, we can clearly see that for the newer projects, the over-representation is overwhelming, with a particular focus on agentic AI (e.g. mcp, ai-agents, openclaw, agent-skills, or simply agents) and explicit mentions of coding agents (claude-code, cursor, opencode). The topics that are not explicitely about artificial intelligence, such as developer tools, cli, productivity, or orchestration, can be implicitly linked to the broad phenomenon of agentic coding tools, that is vastly present in the other topics. In short, there is a large amount of “dogfooding”: coding agents used to drive improvements to AI coding in general. Table 7 shows the differences in adoption for newer vs older projects in some of the top 100 organizations. The list is shorter, as few such organizations created a large number of repositories in that period, that matched our sampling criteria. We see that their adoption has risen in line with the broad trends. Interestingly, while the organizations had a higher level of adoption among the older projects (14.70% adoption overall), this is no longer the case for the newer projects (60% of adoption overall).
7
Lua (19)
Rust (725)
PowerShell (105)
Elixir (29)
HTML (728)
C# (133)
Ruby (53)
C++ (88)
Shell (1257)
Swift (176)
Python (1399)
Jupyter Notebook (29)
JavaScript (1213)
Batchfile (32)
Svelte (71)
Kotlin (115)
Java (48)
SCSS (29)
C (151) Go (455)
Zig (34)
TSX (1322)
Vue (96) Dart (34)
TypeScript (2114) 0
20
40 60 Percentage
80
100
0
20
40 60 Percentage
80
100
Figure 3: Distribution of commit ratio by language for newer projects
R (61) Batchfile (35) C# (520) PowerShell (115) F# (21) HTML (651) Shell (1217) Assembly (24) GLSL (17) Perl (15) Swift (208) Julia (38) Ruby (236) JavaScript (1963) Python (2103) Groovy (27) Kotlin (299) Java (466) TypeScript (3175) Clojure (16)
Haskell (18) Vue (294) Scala (51) Go (962) SCSS (269) Jupyter Notebook (130) TSX (1734) Rust (785) C (448) C++ (431) GraphQL (77) Solidity (30) Starlark (42) Lua (49) Objective-C++ (25) Dart (113) Svelte (83) Cuda (23) Elixir (40) 0
20
40 60 Percentage
80
100
0
20
40 60 Percentage
80
Figure 4: Distribution of commit ratio by language for older projects
8
100
Language Shell Rust Batchfile Powershell HTML Svelte Swift TSX Elixir Typescript Python Javascript Go Lua Kotlin C Vue Dart C# Jupyter Ruby C++ SCCS Java
Table 6: Language Evolution New % New Old % Old 1257 18.26% 1217 8.18% 725 10.53% 785 5.28% 32 0.46% 35 0.24% 105 1.53% 115 0.77% 651 9.46% 728 4.89% 71 1.03% 83 0.56% 176 2.56% 208 1.40% 1322 19.20% 1734 11.66% 29 0.42% 40 0.27% 2114 30.71% 3175 21.35% 1399 20.32% 2103 14.14% 1213 17.62% 1963 13.20% 455 6.61% 962 6.47% 19 0.28% 49 0.33% 115 1.67% 299 2.01% 151 2.19% 448 3.01% 96 1.39% 294 1.98% 34 0.49% 113 0.76% 133 1.93% 520 3.50% 29 0.42% 130 0.87% 53 0.77% 256 1.72% 88 1.28% 431 2.90% 29 0.42% 269 1.81% 48 0.70% 466 3.13%
Evolution (%) 223.17% 199.55% 197.55% 197.28% 193.21% 184.83% 182.83% 164.73% 156.65% 143.86% 143.74% 133.51% 102.19% 83.78% 83.10% 72.83% 70.55% 65.01% 55.26% 48.20% 44.73% 44.12% 23.29% 22.26%
Table 7: File-based adoption for top 20 organizations Organization Microsoft Amazon Nvidia Google Jetbrains Alibaba Huggingface
5
New Adoption pct
New Repositories
Old Adoption pct
Old Repositories
63.46% 75.00% 56.25% 44.44% 62.50% 57.14% 50.00%
52 24 16 9 8 7 6
30.73% 16.63% 26.17% 10.54% 21.59% 24.56% 24.49%
934 415 107 626 88 57 49
RQ4: Evolution of Adoption Over Time, and Tool-Specific Adoption
We present visualizations of tool-specific adoption patterns and co-adoption relationships. Figure 7 and Figure 8 contrast the adoption timeline for both newer and older projects. Unsurprisingly, the adoption timeline is much sharper for the newer projects. We do see a similar inflection point, in that the number of adopters grows very significantly in early 2026. The spike is of course less sharp, but still visible, for the older projects. Figure 9 and Figure 10 contrast the adoption timeline for both newer and older projects, where the adoption is plotted for each tool. We can clearly see that newer projects have some differences in terms of tool preferences. In particular, Claude Code is the most popular tool in both dataset, but it is by a short margin (≈ 6%) over Copilot in the older projects, while Copilot it a distant third for newer projects. In this corpus, Claude Code is three times more popular. The second category for newer projects is the “Generic” category (mostly identified by their use of AGENTS.md). This includes a sizeable portion of Codex users. Considering the explicit uses of Codex as well, it is likely that Codex is the second most popular tool for the
9
multi-agent (85)
gemini-cli (44)
memory (44)
llm (307)
developer-tools (247)
docker (65)
ai-coding (61)
vibe-coding (56)
sqlite (40)
nodejs (43)
anthropic (122)
openclaw (149)
agent-skills (48)
self-hosted (103)
claude-code (479)
orchestration (41)
devops (43)
agents (137)
skills (81)
ai (512)
claude (305)
security (61)
rag (68)
nextjs (73)
automation (107)
ai-assistant (58)
cli (270)
gemini (110)
ai-tools (73)
codex (174)
ai-agents (367)
opencode (106)
cursor (72)
desktop-app (40)
model-context-protocol (73)
linux (48)
productivity (41)
tui (68)
agentic-ai (101)
terminal (82)
mcp (313)
electron (42)
ai-agent (131)
agent (137)
mcp-server (122)
react (125)
open-source (137)
macos (86)
privacy (43)
openai (83) 0
20
40 60 Percentage
80
100
0
20
40 60 Percentage
80
100
Figure 5: Topic-stratified analysis of commit adoption ratios, comparing adoption patterns across repository categorizations, for newer projects. newer projects, although a distant second to Claude Code. Beyond Claude Code and Codex, other tools that see a comparatively higher usage in newer projects include OpenCode, Amp, and Kiro. Figure 11 and Figure 12 contrast the adoption timeline for both newer and older projects, where the adoption is the number of repositories showing traces of adoption over time, for each entity. We see a rather surprising finding here: while for older projects, the entities that are plotted are established organizations (e.g. Microsoft, Apache, Google, Grafana, etc), for newer projects, a sizeable portion of the entities with the largest adoption (the largest number of adopting repositories) are individuals. This is the case of the entity with the most repositories (“Dicklesworthstone”): during the study period, this single developer created more repositories with coding agent traces than Microsoft. Several other developers have the same behaviour, albeit to a lesser extent.
6
RQ5: Size of AI-Assisted Contributions
We analyze how tool adoption affects commit sizes across the studied repositories.
10
sqlite (49) dotnet (160) openapi (57) claude (71) aws (62) azure (67) rails (41) github (49) shadcn-ui (41) p2p (46) visualization (49) windows (96) langchain (48) css (48) cloud (69) game (49) anthropic (54) ios (139) terraform (47) cross-platform (68) rest-api (40) data-visualization (42) nodejs (239) python3 (43) rust-lang (40) sdk (123) agent (127) agentic-ai (53) macos (100) iot (46) cli (170) android (196) git (50) mobile (42) framework (93) mcp (198) openai (162) gpt (45) frontend (49) flutter (72) chatgpt (73) mysql (61) artificial-intelligence (67) deep-learning (71) linux (108) ollama (49) design-system (60) serverless (42) developer-tools (72) mcp-server (94) machine-learning (149) redis (44) metrics (46) nextjs (217) docker (190) bot (41) observability (64) web3 (52) postgresql (107) data (69) web (79)
0
20
40 60 Percentage
80
100
tailwindcss (109) ai (492) blog (44) laravel (49) library (54) wasm (50) cryptocurrency (41) wordpress (64) react (459) documentation (51) mongodb (60) deepseek (43) devops (88) pytorch (51) vscode (58) video (44) reactjs (79) api (131) llm (364) automation (99) llms (59) microservices (43) security (145) electron (62) cms (49) markdown (77) postgres (50) angular (76) testing (66) vscode-extension (44) ai-agents (69) vuejs (48) compiler (44) analytics (67) monitoring (75) django (54) open-source (149) genai (44) kubernetes (217) react-native (68) ethereum (95) gemini (52) blockchain (131) agents (129) chatbot (58) workflow (51) bitcoin (49) ui (85) components (45) database (138) rag (73) node (41) data-science (64) generative-ai (52) privacy (47) self-hosted (90) terminal (42) cloud-native (49) vite (48) monorepo (49) containers (48)
0
20
40 60 Percentage
80
100
Figure 6: Topic-stratified analysis of commit adoption ratios, comparing adoption patterns across repository categorizations, for older projects. Figure 13 and Figure 14 contrast the sizes of contributions for both newer and older projects. We see a counter-intuitive behaviour: for newer projects, the size difference between AI-assisted and human-authored commits appears smaller than for older projects. Looking into the details, the AI commits are actually larger for newer projects, in terms of lines added: the median for the older projects is 30, versus 42 for newer projects, with a third quartile of 110 for older projects, compared to 156 for newer projects. However, the metrics for contributions classified as human-authored show a marked difference the median is only 10(Q3: 42) for the older projects, while the median rises to 29(Q3: 116). In a context where these projects have a very high level of AI adoption, we regard this drastic increase in the size of human-authored lines of code as implausible. We offer an alternative explanation: rather than reflecting an increase of human-authored productivty, this data reflects an increase of undetected agentic activity. Indeed, at the present we only track explicit signs of agent activity (refer to the original paper for methodological details). However, we know that agentic activity is only partially observable [RMD+ 26b]. In particular, it is very easy to switch off the commit-signing behaviour of an agent such as Claude Code. Likewise, agents such as Pi or OpenCode may simply not sign commits. Therefore, we think that a large amount of commits that we classify at the moment as human authored are in fact AI-assisted, and that this phenomenon is more prevalent for newer projects. Clearly, further study is needed to validate this 11
Cumulative Number of Adopting Projects
8000
6000
4000
2000
0 2025-01
2025-03
2025-05
2025-07
2025-09
Date
2025-11
2026-01
2026-03
Figure 7: Cumulative adoption of any tool across all 8 562 projects from 2025-01-05 to 2026-04-08.
Cumulative Number of Adopting Projects
30000
25000
20000
15000
10000
5000
0 2025-01
2025-03
2025-05
2025-07
2025-09
Date
2025-11
2026-01
2026-03
Figure 8: Cumulative adoption of any tool across all 32 134 projects from 2025-01-01 to 2026-04-05.
12
6,443
298
Claude Code 3,092
Generic
239
Other
230
Amp
227
Jules
196
Coderabbit 2,177
71
Windsurf
Copilot
69
Kiro Devin
59
Cline
59
Speckit
55
Serena
53
Pi
52
Qwen Coder
45
Aider
35
Trae
31
1,719
Other 1,231
Codex
1,064
Cursor
499
Gemini Jan
Opencode
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Jan
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Figure 9: Ridgeline plot showing adoption patterns for the 47 tools, with Claude Code being the most adopted (6 443 projects).
16,897
1,372
Coderabbit 15,794
Claude Code
690
Other
529
Aider
Copilot
464
Devin 6,234
330
Amp
Generic
308
Opencode 5,841
Cline
241
Sourcery
203
Windsurf
178
Junie
172
Openhands
123
Serena
111
Kiro
102
Qwen Coder
87
Other 3,436
Cursor
2,938
Codex
1,408
Gemini Jan
931
Jules
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Jan
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Figure 10: Ridgeline plot showing adoption patterns for the 56 tools, with Claude Code being the most adopted (16 897 projects).
13
110
25
23
Openclaw
Microsoft
Avifenesh
20
Block
20
Hmbown
19
37
Nirholas 37
Vercel
19
Jordanhubbard
18
Hkuds
18
Vercel-Labs 34
Nvidia
31
Amazon
28
Getsentry
26
Bearcove
Alibaba
17
Boostcampwm2025
17
Martian-Engineering
17
Cyberfabric
16
Cloudflare
16
J5Ik2O
16
26
Kilo-Org
25
Snowdreamtech Jan
25
Steipete
97
Dicklesworthstone
Mar
May
Jul
Sep Date
Nov
Jan
First-Fluke
Mar
Jan
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Figure 11: Adoption patterns across the top 35 organizations, with dicklesworthstone leading at 110 adoptions.
740
104 98
Elastic Microsoft 330
Pulumi
71
Iobroker
71
175
Micronaut
63
Mattermost
63
Huggingface
58
Langchain-Ai
57
Apache Openshift
174
131
Grafana
Mongodb
50
Adobe
126
Automattic
49
Tencent 119
Jetbrains
Datadog
117
Cloudflare
Nvidia
111
Getsentry
Jan
55
126 Open-Telemetry
Amazon
48 47 47
Alibaba
Mar
May
Jul
Sep Date
Nov
Jan
45
Vercel
Mar
Jan
Mar
May
Jul
Sep Date
Nov
Jan
Mar
Figure 12: Adoption patterns across the top 35 organizations, with microsoft leading at 740 adoptions.
14
hypothesis. Given this uncertainty, we refrain from analysing the commits further. Added Lines
Total Files 10
1
10
0
10
1
10
0
Human (n=2145223)
Bot (n=117524)
10
1
10
0
Total Files
2
Deleted Lines
Added Lines
10
Deleted Lines
AI Assisted (n=734099)
Human (n=1827913)
Bot (n=96611)
AI Assisted (n=600038)
Human (n=2280091)
Bot (n=123000)
AI Assisted (n=775860)
Figure 13: Boxplot comparison of added lines, deleted lines, and total files across human, bot, and AI-assisted commits for newer projects.
Added Lines
10
1
0
10
10 Human (n=11556578)
Bot (n=1253558)
AI Assisted (n=617227)
1
Total Files
10
Total Files
2
Deleted Lines
Added Lines
10
Deleted Lines
0
6 × 10
0
4 × 10
0
3 × 10
0
2 × 10
0
10 Human (n=10212140)
Bot (n=1208911)
AI Assisted (n=512343)
0
Human (n=12123307)
Bot (n=1233139)
AI Assisted (n=640329)
Figure 14: Boxplot comparison of added lines, deleted lines, and total files across human, bot, and AI-assisted commits for older projects.
7
Discussion
7.1
Limitations
This study shares the same limitation as the original study [RMD+ 26a]. We highlight two in particular: The first is the prevalence of undetected agentic activity [RMD+ 26b]. While this activity is by definition very hard to detect, and thus to be certain of its prevalence, we think that fig. 13 and fig. 14 give us some insights on its prevalence. We think that the undetected agentic activity is much more prevalent in the dataset of newer projects. With that in mind, we think that our conclusions on the commit ratio, as presented here, are incomplete. Even more so than in the dataset of older projects, we think that the AI commit ratio is an undercount of the true AI commit ratio. While there is already a considerable difference in commit ratio between the older and the newer projects, it is likely to be even larger. The second is possible sampling bias. We reused the same filtering criteria (more than 5,000 lines of code, more than 100 commits) as in the previous study for consistency. However, it is possible that these criteria, when applied to younger projects such as the ones here, tend to over-select for agentic projects. If agentic projects have an overall higher activity than non agentic projects, such a mechanism would tend to select them. We think that it is possible for it to be the case, particularly for the number of commits. We note that regular bots can also contribute to a higher commit count (e.g. dependabot), which mitigates this. A similar study with different thresholds might thus arrive to different conclusion. Nevertheless, if smaller and less active projects have less agentic activity, it is still striking to observe so much agentic activity in the most active projects.
15
7.2
Implications
What can we say about this level of agentic activity? This study shares the implication of the previous study, but the magnitude of the agentic activity in these newer projects makes them even more potent. If adoption is steadily increasing in older projects, coding agents are already ubiquitous in the newer projects that we selected. In this dataset, the transition towards coding agents is thus happening faster than we anticipated, with more intensity than we anticipated. Consider in particular Figure 1, compared to Figure 2. There is already a very large difference in terms of commit ratio, but, if anything, we suspect that this difference is undercounted due to undetected agentic activity. As such, we renew our call for thorough studies of this transition towards agentic software development, as it is happening at an unprecedented speed. Another implication concerns the other differences between projects. The choice of using agents is related to significant changes in the way the projects are built. This is already evident in the language distribution, where some languages (such as Rust) are far more common in the newer projects than others (such as Java). While modern coding agents are competent in most kinds of languages, some languages are clearly more favored than others. Rust in particular is a very good language for coding agents, as it has extensive static checks that give very rich feedback to coding agents. The broader implication is that, if such differences appear so quickly, other differences (in terms of tool usage, development styles, etc) might appear as well. These aspects should be extensively studied as well. Yet another implication is the extreme usages observed in some cases. Some users rival, in terms of number of repositories created with agents, with entire organizations such as Microsoft. The fact that some users can be so active in so little time is an even more marked departure with earlier practice. While our previous study called for the study of outliers, we did not expect this kind of outliers, with this kind of intensity. Finally, the last implication is an increased importance of designing approaches to detect coding agent activity. Before this study, we strongly suspected that a large portion of agentic activity is at the moment undetected. This study, and in particular the counter-intuitive result shown in Figure 13 and Figure 14, comfort our opinion. As such, approaches to detect ”secret” coding agent activity are extremely important to better study this phenomenon.
8
Conclusion
We presented a study of the adoption of coding agents for newly created projects. We found that, for our sample, coding agents are already ubiquitous. We found that a large proportion of projects are built almost entirely from coding agents, and that some users have extremely large levels of activity. This is in spite of the fact that a significant amount of this activity is as yet undetected, foreshadowing an even higher degree of true agentic activity. These findings have important implications, renewing and intensifying the calls for extensive study of this phenomenon, that is happening with breathtaking speed.
References [DAB21]
Ozren Dabic, Emad Aghajani, and Gabriele Bavota. Sampling projects in github for msr studies. In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR), pages 560–564. IEEE, 2021.
[RMD+ 26a] Romain Robbes, Théo Matricon, Thomas Degueule, Andre Hora, and Stefano Zacchiroli. Agentic much? adoption of coding agents on github. arXiv preprint arXiv:2601.18341, 2026. [RMD+ 26b] Romain Robbes, Théo Matricon, Thomas Degueule, Andre Hora, and Stefano Zacchiroli. Promises, perils, and (timely) heuristics for mining coding agent activity. In MSR 2026-23rd IEEE Working Conference on Mining Software Repositories, 2026.
16