arxiv: 2604.03551 · v2 · submitted 2026-04-04 · 💻 cs.SE · cs.AI· cs.HC

Recognition: unknown

AgenticFlict: A Large-Scale Dataset of Merge Conflicts in AI Coding Agent Pull Requests on GitHub

Daniel Ogenrwot , John Businge

Authors on Pith no claims yet

Pith reviewed 2026-05-14 21:12 UTC · model grok-4.3

classification 💻 cs.SE cs.AIcs.HC

keywords merge conflictsAI coding agentspull requestsGitHubdatasetsoftware integrationagentic development

0 comments

The pith

A dataset of 142K AI coding agent pull requests shows merge conflicts arise in 27.67 percent of cases.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper builds a large dataset called AgenticFlict to measure how often AI-generated code changes create merge conflicts during integration. It collects over 142,000 pull requests from 59,000 GitHub repositories, runs deterministic merge simulations on 107,000 of them, and isolates 29,000 conflicting cases containing 336,000 specific conflict regions. A sympathetic reader cares because this quantifies a practical barrier in the shift toward AI agents as active code contributors rather than mere assistants. The work finds that conflicts appear frequently and vary by agent, pointing to the need for better integration strategies in agent-driven development.

Core claim

We present AgenticFlict, a dataset of 142K+ Agentic PRs from 59K+ repositories of which 107K+ are processed via deterministic merge simulation, identifying 29K+ PRs with conflicts at a 27.67% rate and extracting 336K+ fine-grained conflict regions. Preliminary analysis shows these conflicts occur often, are frequently substantial, and differ noticeably across agents.

What carries the argument

The pipeline that collects AI-labeled pull requests from GitHub and applies deterministic merge simulation to extract and count textual conflict regions.

If this is right

Merge conflicts arise in more than one quarter of AI agent pull requests.
Conflict frequency and size vary across different AI coding agents.
Integration of agent-generated code requires specific handling beyond standard human workflows.
The extracted 336K conflict regions provide a resource for studying patterns in agent code changes.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Teams adopting multiple agents may need agent-specific merge policies or resolution tools.
The dataset could support training new agents to generate changes that merge more cleanly.
Future work might compare these rates directly to conflict rates in human-authored pull requests from the same repositories.
Large-scale mining of this data could reveal recurring conflict locations such as configuration files or dependency declarations.

Load-bearing premise

The collected pull requests are correctly labeled as AI-generated and the deterministic merge simulation accurately reproduces the conflicts that would occur in real repositories.

What would settle it

Manually review a random sample of 500 identified conflicting PRs to verify both AI agent authorship and the presence of the reported merge conflicts in the simulated output.

Figures

Figures reproduced from arXiv: 2604.03551 by Daniel Ogenrwot, John Businge.

**Figure 1.** Figure 1: summarizes the multi-stage workflow used to construct the AgenticFlict dataset. The pipeline consists of five main stages: (1) Agentic PR collection from the AIDev dataset, (2) Metadata Retrieval, (3) repository preparation, (4) deterministic merge simulation (5) conflict extraction. Step 1: Pull Request Collection. We use the AIDev dataset [34] downloaded from Hugging Face as of January 5, 2026. The da… view at source ↗

**Figure 2.** Figure 2: Dataset Schema of AgenticFlict. and mergeability signals. In addition, it records reconstruction outcomes, including whether a conflict occurs and aggregate severity metrics such as the number of conflicting files, number of conflict regions, and total conflict lines. ConflictFile. This entity captures file-level conflict information and is linked to the pull request entity via pr_key. Each record corresp… view at source ↗

**Figure 3.** Figure 3: Conflict rates across AI coding agents with 95% [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

**Figure 4.** Figure 4: Distribution of conflict severity (measured as con [PITH_FULL_IMAGE:figures/full_fig_p005_4.png] view at source ↗

**Figure 5.** Figure 5: Conflict rate as a function of pull request size (mea [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗

read the original abstract

Software Engineering 3.0 marks a paradigm shift in software development, in which AI coding agents are no longer just assistive tools but active contributors. While prior empirical studies have examined productivity gains and acceptance patterns in AI-assisted development, the challenges associated with integrating agent-generated contributions remain less understood. In particular, merge conflicts, a fundamental aspect of collaborative software development, remain underexplored in this context. In this paper, we present AgenticFlict, a large-scale dataset of textual merge conflicts in AI coding agent pull requests (Agentic PRs). The dataset comprises 142K+ Agentic PRs collected from 59K+ repositories, of which 107K+ are successfully processed through deterministic merge simulation. Our pipeline identifies 29K+ PRs exhibiting merge conflicts, yielding a conflict rate of 27.67%, and extracts 336K+ fine-grained conflict regions across these instances. Our preliminary exploratory analysis indicates that merge conflicts are both frequent and often substantial in AI-generated contributions, with noticeable variation across agents, emphasizing the need to better understand and manage integration challenges in AI-assisted software development. The dataset, code and supplementary materials are available in zenodo: https://doi.org/10.5281/zenodo.19396916.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

This paper releases the first large public dataset of merge conflicts from AI coding agent PRs, with solid scale and clear numbers that make it worth using.

read the letter

The main thing to know is that they built and shared AgenticFlict, pulling 142k+ Agentic PRs from 59k repositories, running 107k through merge simulation, and surfacing 29k+ conflicts at 27.67% with 336k+ fine-grained regions. That scale and the public Zenodo release are the real contribution, since earlier AI-assisted development studies have not produced a comparable collection focused on integration friction. The preliminary analysis also shows variation across agents, which matches what teams are running into as these tools get used more in collaborative repos. The data collection pipeline is described at a high level with concrete counts, and the deterministic simulation approach keeps things reproducible on the surface. The labeling of AI agents and the exact merge strategy details are not fully expanded in what I saw, so a referee would want to check for selection bias or missed edge cases in how PRs were tagged and simulated. Those are standard risks for dataset papers rather than fatal problems. This is useful for anyone working on AI code integration, conflict detection tools, or empirical studies of agent contributions. It is not a deep theoretical advance, but the resource itself is new and usable. I would send it to peer review so the methods can be stress-tested against the released code and data.

Referee Report

2 major / 2 minor

Summary. The paper presents AgenticFlict, a large-scale dataset of textual merge conflicts in AI coding agent pull requests (Agentic PRs) on GitHub. It describes a collection pipeline yielding 142K+ Agentic PRs from 59K+ repositories, with 107K+ successfully processed via deterministic merge simulation; this identifies 29K+ conflicting PRs (27.67% rate) and extracts 336K+ fine-grained conflict regions. Preliminary exploratory analysis indicates conflicts are frequent, often substantial, and vary across agents, with the dataset, code, and materials released via Zenodo.

Significance. If the AI-agent labeling and merge simulation are reliable, the dataset offers a valuable empirical resource for studying integration challenges in AI-assisted software development. Its scale (29K+ conflicting PRs and 336K+ regions) and public availability enable reproducible research on conflict patterns, which prior work has not addressed at this granularity for agent-generated code.

major comments (2)

[Data collection pipeline] Data collection pipeline (likely §3): the exact criteria and heuristics for labeling PRs as 'Agentic' (e.g., bot detection rules, commit message patterns, or repository filters) must be specified in detail; without them the 142K+ count and 27.67% conflict rate cannot be independently verified or replicated.
[Merge simulation] Merge simulation subsection: the deterministic merge strategy (including conflict detection logic, handling of binary files, or three-way merge parameters) should be described with pseudocode or explicit steps, as the reported 336K+ regions depend on this implementation matching real Git behavior.

minor comments (2)

[Exploratory analysis] Add a table summarizing per-agent conflict rates and region sizes to support the claim of 'noticeable variation across agents'.
[Discussion] Include a limitations paragraph discussing potential false positives in AI-agent identification and any GitHub API rate-limit effects on the 59K+ repository sample.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback and the recommendation for minor revision. We have revised the manuscript to address both major comments by expanding the descriptions of the data collection pipeline and merge simulation with the requested details.

read point-by-point responses

Referee: [Data collection pipeline] Data collection pipeline (likely §3): the exact criteria and heuristics for labeling PRs as 'Agentic' (e.g., bot detection rules, commit message patterns, or repository filters) must be specified in detail; without them the 142K+ count and 27.67% conflict rate cannot be independently verified or replicated.

Authors: We agree that the labeling criteria require more explicit specification for full reproducibility. The revised manuscript now includes a dedicated subsection in §3 that details the exact heuristics: GitHub bot label detection combined with username patterns (e.g., ending in [bot]), commit message signatures matching common AI agent outputs (e.g., phrases like 'Co-authored-by: Copilot' or 'generated by'), and repository filters excluding forks and archived repos. A summary table of these rules has also been added. These additions allow independent verification of the 142K+ Agentic PRs and the 27.67% conflict rate. revision: yes
Referee: [Merge simulation] Merge simulation subsection: the deterministic merge strategy (including conflict detection logic, handling of binary files, or three-way merge parameters) should be described with pseudocode or explicit steps, as the reported 336K+ regions depend on this implementation matching real Git behavior.

Authors: We accept this point and have strengthened the description. The revised manuscript now contains explicit algorithmic steps and pseudocode for the deterministic merge simulation, covering: (1) checkout of base and head commits, (2) invocation of Git's three-way merge with default parameters, (3) detection of textual conflicts via '<<<<<<<', '=======', and '>>>>>>>' markers, and (4) exclusion of binary files from region extraction (they are counted separately but not parsed for textual regions). This matches the released code on Zenodo and ensures the 336K+ fine-grained regions are replicable. revision: yes

Circularity Check

0 steps flagged

No significant circularity

full rationale

This is a pure empirical dataset paper. The central claims consist of counts and rates obtained by running a data-collection pipeline (PR filtering, deterministic merge simulation, conflict-region extraction) over GitHub data. No equations, predictions, fitted parameters, or self-citations are used to derive those counts; the numbers are direct outputs of the described processing steps. The two external validation points (AI-agent labeling and merge-simulation fidelity) are standard dataset-construction risks, not internal circular reductions. Consequently the derivation chain contains no self-definitional, fitted-input, or self-citation load-bearing steps.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Empirical dataset paper with no mathematical model, free parameters, axioms, or invented entities. Relies on standard assumptions of Git merge behavior and PR authorship labeling.

pith-pipeline@v0.9.0 · 5535 in / 1078 out tokens · 43490 ms · 2026-05-14T21:12:58.217180+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

60 extracted references · 60 canonical work pages · 3 internal anchors

[1]

Paola Accioly, Paulo Borba, and Guilherme Cavalcanti. 2018. Understanding semi- structured merge conflict characteristics in open-source Java projects.Empirical Software Engineering23, 4 (2018), 2051–2085. doi:10.1007/s10664-017-9586-1

work page doi:10.1007/s10664-017-9586-1 2018
[2]

Adam Alami and Neil Ernst. 2025. Human and Machine: How Software Engineers Perceive and Engage with AI-Assisted Code Reviews Compared to Their Peers. In 2025 IEEE/ACM 18th International Conference on Cooperative and Human Aspects of Software Engineering (CHASE). 63–74. doi:10.1109/CHASE66643.2025.00016

work page doi:10.1109/chase66643.2025.00016 2025
[3]

2026.AgenticFlict: A Large-Scale Dataset of Merge Conflicts in AI Coding Agent Pull Requests on GitHub

Anonymous. 2026.AgenticFlict: A Large-Scale Dataset of Merge Conflicts in AI Coding Agent Pull Requests on GitHub. doi:10.5281/zenodo.19396917

work page doi:10.5281/zenodo.19396917 2026
[4]

Anthropic. 2025. Claude.ai. https://claude.ai/. Accessed: 2025-12-14

work page 2025
[5]

Rigby, Earl T

Christian Bird, Peter C. Rigby, Earl T. Barr, David J. Hamilton, Daniel M. German, and Prem Devanbu. 2009. The promises and perils of mining git. In2009 6th IEEE International Working Conference on Mining Software Repositories. 1–10. doi:10.1109/MSR.2009.5069475

work page doi:10.1109/msr.2009.5069475 2009
[6]

Caius Brindescu, Iftekhar Ahmed, Rafael Leano, and Anita Sarma. 2020. Planning for untangling: predicting the difficulty of merge conflicts. InProceedings of the ACM/IEEE 42nd International Conference on Software Engineering(Seoul, South Korea)(ICSE ’20). Association for Computing Machinery, New York, NY, USA, 801–811. doi:10.1145/3377811.3380344

work page doi:10.1145/3377811.3380344 2020
[7]

Ernst, and David Notkin

Yuriy Brun, Reid Holmes, Michael D. Ernst, and David Notkin. 2013. Early Detection of Collaboration Conflicts and Risks.IEEE Transactions on Software Engineering39, 10 (2013), 1358–1375. doi:10.1109/TSE.2013.28

work page doi:10.1109/tse.2013.28 2013
[8]

John Businge, Alexandre Decan, Ahmed Zerouali, Tom Mens, and Serge Demeyer

work page
[9]

InProceedings of the 19th Belgium-Netherlands Software Evolution Workshop, BENEVOL 2020, Luxembourg, December 3-4, 2020 (CEUR Workshop Proceedings, Vol

An Empirical Investigation of Forks as Variants in the npm Package Distribution. InProceedings of the 19th Belgium-Netherlands Software Evolution Workshop, BENEVOL 2020, Luxembourg, December 3-4, 2020 (CEUR Workshop Proceedings, Vol. 2912), Mike Papadakis and Maxime Cordy (Eds.). CEUR-WS.org. http://ceur-ws.org/Vol-2912/paper1.pdf

work page 2020
[10]

John Businge, Moses Openja, Sarah Nadi, Engineer Bainomugisha, and Thorsten Berger. 2018. Clone-Based Variability Management in the Android Ecosystem. In International Conference on Software Maintenance and Evolution. IEEE, 625–634

work page 2018
[11]

John Businge, Moses Openja, Sarah Nadi, and Thorsten Berger. 2022. Reuse and Maintenance Practices among Divergent Forks in Three Software Ecosystems. Journal of Empirical Software Engineering27, 2 (2022), 54. doi:10.1007/s10664- 021-10078-2

work page doi:10.1007/s10664- 2022
[12]

Campos Junior, Gleiph Ghiotto L

Heleno de S. Campos Junior, Gleiph Ghiotto L. de Menezes, Márcio de Oliveira Barros, André van der Hoek, and Leonardo Gresta Paulino Murta. 2022. Towards Merge Conflict Resolution by Combining Existing Lines of Code. InProceedings of the XXXVI Brazilian Symposium on Software Engineering(Virtual Event, Brazil) (SBES ’22). Association for Computing Machiner...

work page doi:10.1145/3555228.3555229 2022
[13]

Campos Junior, Gleiph Ghiotto L

Heleno de S. Campos Junior, Gleiph Ghiotto L. de Menezes, Márcio de Oliveira Barros, André van der Hoek, and Leonardo Gresta Paulino Murta. 2025. Towards a feasible evaluation function for search-based merge conflict resolution.ACM Trans. Softw. Eng. Methodol.(July 2025). doi:10.1145/3748256 Just Accepted

work page doi:10.1145/3748256 2025
[14]

Cánovas Izquierdo, and Jordi Cabot

Valerio Cosentino, Javier L. Cánovas Izquierdo, and Jordi Cabot. 2017. A System- atic Mapping Study of Software Development With GitHub.IEEE Access5 (2017), 7173–7192. doi:10.1109/ACCESS.2017.2682323

work page doi:10.1109/access.2017.2682323 2017
[15]

Kevin Zheyuan Cui, Mert Demirer, Sonia Jaffe, Leon Musolff, Sida Peng, and Tobias Salz. 2026. The effects of generative AI on high-skilled work: Evidence from three field experiments with software developers.Management Science (2026)

work page 2026
[16]

Cursor. 2025. Cursor: AI Code Editor. https://cursor.com/. Accessed: 2025-12-14

work page 2025
[17]

Devin AI. 2025. Devin AI — AI Coding Assistant. https://app.devin.ai/. Accessed: 2025-12-14

work page 2025
[18]

Roberto Di Cosmo and Stefano Zacchiroli. 2017. Software heritage: Why and how to preserve software source code. IniPRES 2017. Conference acronym ’XX, June 03–05, 2018, Woodstock, NY Daniel Ogenrwot and John Businge

work page 2017
[19]

Gleiph Ghiotto, Leonardo Murta, Márcio Barros, and André van der Hoek. 2020. On the Nature of Merge Conflicts: A Study of 2,731 Open Source Java Projects Hosted by GitHub.IEEE Transactions on Software Engineering46, 8 (2020), 892–

work page 2020
[20]

doi:10.1109/TSE.2018.2871083

work page doi:10.1109/tse.2018.2871083 2018
[21]

Git Project. 2026. Partial Clone. https://git-scm.com/docs/partial-clone. Accessed: 2026-04-02

work page 2026
[22]

GitHub Copilot. 2025. GitHub Copilot. https://github.com/copilot. Accessed: 2025-12-14

work page 2025
[23]

GitHub, Inc. 2026. GitHub Terms of Service. https://docs.github.com/en/site- policy/github-terms/github-terms-of-service. Accessed: 2026-04-02

work page 2026
[24]

GitHub, Inc. 2026. GraphQL API. https://docs.github.com/en/graphql. Accessed: 2026-04-02

work page 2026
[25]

GitHub, Inc. 2026. Rate limits and query limits for the GraphQL API. https://docs.github.com/en/graphql/overview/rate-limits-and-query-limits- for-the-graphql-api. Accessed: 2026-04-02

work page 2026
[26]

Ismail Sergen Göçmen, Ahmed Salih Cezayir, and Eray Tüzün. 2025. Enhanced code reviews using pull request based change impact analysis.Empirical Software Engineering30, 3 (2025), 64. doi:10.1007/s10664-024-10600-2

work page doi:10.1007/s10664-024-10600-2 2025
[27]

Pavlína Wurzel Gonçalves, Pooja Rani, Margaret-Anne Storey, Diomidis Spinellis, and Alberto Bacchelli. 2025. Code Review Comprehension: Reviewing Strategies Seen Through Code Comprehension Theories. In2025 IEEE/ACM 33rd Inter- national Conference on Program Comprehension (ICPC). 589–601. doi:10.1109/ ICPC66645.2025.00068

work page arXiv 2025
[28]

Georgios Gousios. 2013. The GHTorent dataset and tool suite. In2013 10th Working Conference on Mining Software Repositories (MSR). 233–236. doi:10.1109/ MSR.2013.6624034

work page arXiv 2013
[29]

Georgios Gousios, Martin Pinzger, and Arie van Deursen. 2014. An exploratory study of the pull-based software development model. InProceedings of the 36th International Conference on Software Engineering(Hyderabad, India)(ICSE 2014). Association for Computing Machinery, New York, NY, USA, 345–355. doi:10. 1145/2568225.2568260

work page arXiv 2014
[30]

Mário Luís Guimarães and António Rito Silva. 2012. Improving early detection of software merge conflicts. In2012 34th International Conference on Software Engineering (ICSE). 342–352. doi:10.1109/ICSE.2012.6227180

work page doi:10.1109/icse.2012.6227180 2012
[31]

Hassan, Hao Li, Dayi Lin, Bram Adams, Tse-Hsun Chen, Yutaro Kashiwa, and Dong Qiu

Ahmed E. Hassan, Hao Li, Dayi Lin, Bram Adams, Tse-Hsun Chen, Yutaro Kashiwa, and Dong Qiu. 2025. Agentic Software Engineering: Foundational Pillars and a Research Roadmap. arXiv:2509.06216 [cs.SE] https://arxiv.org/abs/ 2509.06216

work page arXiv 2025
[32]

Hassan, Gustavo A

Ahmed E. Hassan, Gustavo A. Oliva, Dayi Lin, Boyuan Chen, Zhen Ming, and Jiang. 2024. Towards AI-Native Software Engineering (SE 3.0): A Vision and a Challenge Roadmap. arXiv:2410.06107 [cs.SE] https://arxiv.org/abs/2410.06107

work page arXiv 2024
[33]

Kosei Horikawa, Hao Li, Yutaro Kashiwa, Bram Adams, Hajimu Iida, and Ahmed E Hassan. 2025. Agentic Refactoring: An Empirical Study of AI Coding Agents. arXiv preprint arXiv:2511.04824(2025)

work page arXiv 2025
[34]

German, and Daniela Damian

Eirini Kalliamvakou, Georgios Gousios, Kelly Blincoe, Leif Singer, Daniel M. German, and Daniela Damian. 2014. The promises and perils of mining GitHub. InProceedings of the 11th Working Conference on Mining Software Repositories (Hyderabad, India)(MSR 2014). Association for Computing Machinery, New York, NY, USA, 92–101. doi:10.1145/2597073.2597074

work page doi:10.1145/2597073.2597074 2014
[35]

Oleksii Kononenko, Olga Baysal, and Michael W. Godfrey. 2016. Code review quality: how developers see it. InProceedings of the 38th International Conference on Software Engineering(Austin, Texas)(ICSE ’16). Association for Computing Machinery, New York, NY, USA, 1028–1038. doi:10.1145/2884781.2884840

work page doi:10.1145/2884781.2884840 2016
[36]

Hao Li, Haoxiang Zhang, and Ahmed E. Hassan. 2025. The Rise of AI Team- mates in Software Engineering (SE) 3.0: How Autonomous Coding Agents Are Reshaping Software Engineering.arXiv preprint arXiv:2507.15003(2025)

work page arXiv 2025
[37]

Wardah Mahmood, Moses Chagama, Thorsten Berger, and Regina Hebig. 2020. Causes of merge conflicts: a case study of ElasticSearch. InProceedings of the 14th International Working Conference on Variability Modelling of Software-Intensive Systems(Magdeburg, Germany)(VaMoS ’20). Association for Computing Machin- ery, New York, NY, USA, Article 9, 9 pages. doi...

work page doi:10.1145/3377024.3377047 2020
[38]

Shane McKee, Nicholas Nelson, Anita Sarma, and Danny Dig. 2017. Software Practitioner Perspectives on Merge Conflicts and Resolutions. In2017 IEEE In- ternational Conference on Software Maintenance and Evolution (ICSME). 467–478. doi:10.1109/ICSME.2017.53

work page doi:10.1109/icsme.2017.53 2017
[39]

Daniel Ogenrwot and John Businge. 2024. PatchTrack: Analyzing ChatGPT’s Impact on Software Patch Decision-Making in Pull Requests. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (Sacramento, CA, USA)(ASE ’24). Association for Computing Machinery, New York, NY, USA, 2480–2481. doi:10.1145/3691620.3695338

work page doi:10.1145/3691620.3695338 2024
[40]

Daniel Ogenrwot and John Businge. 2025. PatchTrack: A Comprehensive Analysis of ChatGPT’s Influence on Pull Request Outcomes. arXiv:2505.07700 [cs.SE] https://arxiv.org/abs/2505.07700

work page internal anchor Pith review Pith/arXiv arXiv 2025
[41]

Daniel Ogenrwot and John Businge. 2025. Refactoring-Aware Patch Integration Across Structurally Divergent Java Forks. In2025 IEEE International Conference on Source Code Analysis & Manipulation (SCAM). 25–36. doi:10.1109/SCAM67354. 2025.00010

work page doi:10.1109/scam67354 2025
[42]

Daniel Ogenrwot and John Businge. 2026. How AI Coding Agents Modify Code: A Large-Scale Study of GitHub Pull Requests. arXiv:2601.17581 [cs.SE] https://arxiv.org/abs/2601.17581

work page internal anchor Pith review Pith/arXiv arXiv 2026
[43]

OpenAI. 2025. Codex — OpenAI. https://openai.com/codex/. Accessed: 2025-12- 14

work page 2025
[44]

Moein Owhadi-Kareshk, Sarah Nadi, and Julia Rubin. 2019. Predicting Merge Conflicts in Collaborative Software Development. In2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 1–11. doi:10.1109/ESEM.2019.8870173

work page doi:10.1109/esem.2019.8870173 2019
[45]

Sida Peng, Eirini Kalliamvakou, Peter Cihon, and Mert Demirer. 2023. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot.arXiv preprint arXiv:2302.06590(2023). doi:10.48550/arXiv.2302.06590 Submitted on 13 Feb 2023

work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.2302.06590 2023
[46]

Poedjadevie Kadjel Ramkisoen, John Businge, Brent van Bladel, Alexandre Decan, Serge Demeyer, Coen De Roover, and Foutse Khomh. 2022. PaReco: patched clones and missed patches among the divergent variants of a software family. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Enginee...

work page doi:10.1145/3540250.3549112 2022
[47]

Henrique Rocha and John Businge. 2022. Blockchain-Oriented Software Variant Forks: A Preliminary Study. In5th International Workshop on Blockchain Oriented Software Engineering

work page 2022
[48]

Bowen Shen, Muhammad Ali Gulzar, Fei He, and Na Meng. 2023. A Characteriza- tion Study of Merge Conflicts in Java Projects.ACM Trans. Softw. Eng. Methodol. 32, 2, Article 40 (March 2023), 28 pages. doi:10.1145/3546944

work page doi:10.1145/3546944 2023
[49]

Bowen Shen and Na Meng. 2024. ConflictBench: A benchmark to evaluate software merge tools.Journal of Systems and Software214 (2024), 112084. doi:10. 1016/j.jss.2024.112084

work page arXiv 2024
[50]

Islam, Iman Keivanloo, Chanchal K

Jeffrey Svajlenko, Judith F. Islam, Iman Keivanloo, Chanchal K. Roy, and Moham- mad Mamun Mia. 2014. Towards a Big Data Curated Benchmark of Inter-project Code Clones. In2014 IEEE International Conference on Software Maintenance and Evolution. 476–480. doi:10.1109/ICSME.2014.77

work page doi:10.1109/icsme.2014.77 2014
[51]

Alexey Svyatkovskiy, Sarah Fakhoury, Negar Ghorbani, Todd Mytkowicz, Eliza- beth Dinella, Christian Bird, Jinu Jang, Neel Sundaresan, and Shuvendu K. Lahiri

work page
[52]

InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering(Singapore, Singapore)(ESEC/FSE 2022)

Program merge conflict resolution via neural transformers. InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering(Singapore, Singapore)(ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 822–833. doi:10.1145/3540250.3549163

work page doi:10.1145/3540250.3549163 2022
[53]

Glassman

Priyan Vaithilingam, Zheng Xu, and Elena L. Glassman. 2023. Copilot or Co- Author? Examining the Role of Code Generation Tools in Collaborative Pro- gramming. InProceedings of the 2023 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, USA

work page 2023
[54]

Glassman

Priyan Vaithilingam, Tianyi Zhang, and Elena L. Glassman. 2022. Expectation vs. Experience: Evaluating the Usability of Code Generation Tools Powered by Large Language Models. InProceedings of the 2022 CHI Conference on Human Factors in Computing Systems. ACM, USA, 1–17

work page 2022
[55]

Gustavo Vale, Eduardo Fernandes, Eduardo Figueiredo, and Sven Apel. 2023. Behind Developer Contributions on Conflicting Merge Scenarios. In2023 IEEE 23rd International Working Conference on Source Code Analysis and Manipulation (SCAM). 25–36. doi:10.1109/SCAM59687.2023.00014

work page doi:10.1109/scam59687.2023.00014 2023
[56]

Gustavo Vale, Claus Hunsen, Eduardo Figueiredo, and Sven Apel. 2022. Chal- lenges of Resolving Merge Conflicts: A Mining and Survey Study.IEEE Trans- actions on Software Engineering48, 12 (2022), 4964–4985. doi:10.1109/TSE.2021. 3130098

work page doi:10.1109/tse.2021 2022
[57]

Manushree Vijayvergiya, Małgorzata Salawa, Ivan Budiselić, Dan Zheng, Pascal Lamblin, Marko Ivanković, Juanjo Carin, Mateusz Lewko, Jovan Andonov, Goran Petrović, Daniel Tarlow, Petros Maniatis, and René Just. 2024. AI-Assisted As- sessment of Coding Practices in Modern Code Review. InProceedings of the 1st ACM International Conference on AI-Powered Softw...

work page doi:10.1145/3664646.3665664 2024
[58]

Miku Watanabe, Hao Li, Yutaro Kashiwa, Brittany Reid, Hajimu Iida, and Ahmed E. Hassan. 2025. On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub. arXiv:2509.14745 [cs.SE] https://arxiv.org/abs/2509.14745

work page arXiv 2025
[59]

Tao Xiao, Christoph Treude, Hideaki Hata, and Kenichi Matsumoto. 2024. De- vGPT: Studying Developer-ChatGPT Conversations. InProceedings of the 21st International Conference on Mining Software Repositories(Lisbon, Portugal)(MSR ’24). Association for Computing Machinery, New York, NY, USA, 227–230. doi:10.1145/3643991.3648400

work page doi:10.1145/3643991.3648400 2024
[60]

Alice Li, Andrew Rice, Devon Rifkin, Shawn Simister, Ganesh Sittampalam, and Edward Aftandilian

Albert Ziegler, Eirini Kalliamvakou, X. Alice Li, Andrew Rice, Devon Rifkin, Shawn Simister, Ganesh Sittampalam, and Edward Aftandilian. 2022. Productivity assessment of neural code completion. InProceedings of the 6th ACM SIGPLAN International Symposium on Machine Programming(San Diego, CA, USA)(MAPS 2022). Association for Computing Machinery, New York, ...

work page arXiv 2022