Pith. sign in

REVIEW 4 major objections 5 minor 51 references

LLM-Driven Collaborative Model for Untangling Commits via Explicit and Implicit Dependency Reasoning

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A three-agent LLM consultation framework untangles mixed commits more accurately than all prior baselines on the standard C# and Java benchmarks.

desk verdict A credible multi-agent LLM framework for commit untangling, but the headline gains over non-LLM baselines are likely inflated by pretraining leakage; the real signal is the margin over single-LLM baselines. read the letter →

arxiv 2507.16395 v3 pith:AHJQEY6I submitted 2025-07-22 cs.AI cs.SE

Bo Hou , Xin Tan , Kai Zheng , Fang Liu , Yinghao Zhu , Li Zhang This is my paper
classification cs.AIcs.SE
keywords commituntanglingtangledcommitsLLM-drivenagentsmulti-agentcollaborationexplicitdependenciesimplicitprogramdependencygraphcodereview
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper is trying to establish that tangled commits—individual commits that mix several unrelated development concerns—can be split into atomic, single-concern commits much more accurately by a team of collaborating large language model agents than by prior rule-based, feature-based, or graph-based untangling tools. The proposed system, ColaUntangle, distinguishes explicit dependencies (data and control flow recovered from program dependency graphs) from implicit dependencies (semantic similarity, structural resemblance, and cosmetic edits), feeds each type to a specialized worker agent, and lets a reviewer agent reconcile the two perspectives through iterative consultation. On two widely used benchmarks, 1,612 C# and roughly 14k Java artificially tangled commits, the paper reports that ColaUntangle improves the best baseline by 44% and 82% respectively on the Accuracy_c metric. The same multi-agent design also produces human-readable explanations for every grouping decision, which earlier black-box models did not provide.

What carries the argument

The load-bearing mechanism is the Commit-Level Merged Graph, built by merging the program dependency graphs (PDGs) of the code before and after the commit, marking deleted and added nodes from the diff, and consolidating unchanged nodes via fuzzy matching. From this graph, ColaUntangle extracts the Explicit Context, a compressed subgraph of only changed nodes with shortcut edges added along any dependency path, and the Implicit Context, the subgraph of changed nodes plus their one-hop neighbors. These feed two worker agents: the explicit agent applies data/control dependency rules to the Explicit Context and diff, the implicit agent applies similarity and cosmetic-edit rules to the Implicit Context and diff, and a reviewer agent synthesizes the two results, then repeatedly revises them in response to the workers' validation opinions. The iterative consultation loop (consensus or three-round cap) is what converts the two partial perspectives into the final untangling decision.

What would settle it

Re-run ColaUntangle and the strongest baselines (HD-GNN and UTango) on the same C# and Java datasets after independently re-labeling the cases the paper's error analysis flags as composite commits and file-formatting artifacts (roughly 20 of 50 sampled errors), then compare Accuracy_c; if the reported 44% and 82% margins shrink to near-zero on the corrected labels, the headline result was largely an artifact of debatable ground truth.

Watch

Extended reading notes

Core claim

ColaUntangle's central claim is that the dichotomy between explicit and implicit dependencies is the right decomposition for commit untangling, and that this decomposition can be operationalized through LLM agents rather than hand-crafted rules or trained graph models. The system builds a Commit-Level Merged Graph from the program dependency graphs of the before and after versions of each modified file, then extracts two views: an Explicit Context containing only changed nodes joined by shortcut edges along dependency paths, and an Implicit Context containing changed nodes plus their one-hop neighbors. An explicit worker agent reasons over the former using data/control dependency rules, an implicit worker agent reasons over the latter using similarity and cosmetic-edit rules, and a reviewer agent iteratively synthesizes, revises, and finalizes their outputs until consensus or a maximum of three rounds. On the C# dataset ColaUntangle reaches 72% Accuracy_c versus 50% for the best graph baseline, and on the Java dataset 69% versus 38%, and the ablation study attributes the largest share of this gain to the collaborative consultation step itself rather than to the structured contexts alone.

Load-bearing premise

The empirical claim rests on the assumption that the two benchmark datasets' ground-truth concern labels are correct and representative of real tangled commits; the paper's own error analysis in Section 6.1 reports 17 'composite commit' cases where a dataset label actually bundles multiple unrelated activities, so some gold labels are themselves debatable.

Editorial extensions

If this is right

  • The 44% and 82% Accuracy_c gains reported over the strongest baseline (HD-GNN) mean automated commit untangling moves from below 50% to roughly 70% on standard benchmarks, suggesting the task is now tractable enough for practical tooling.
  • Because ColaUntangle can untangle comment statements and cosmetic edits that PDG-based methods cannot represent, the resulting atomic commits are closer to what a human reviewer would produce.
  • The ablation finding that removing collaborative consultation costs 16.9% accuracy, more than removing the structured contexts (8.45%), indicates that the consensus-seeking dialogue between specialized perspectives carries the main explanatory weight.
  • The framework does not depend on a single LLM: five tested models all reach competitive accuracy, so the approach generalizes across model providers.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A relabeling study of the 17 composite-commit cases the paper itself flags in its error analysis could show that part of the reported advantage comes from ColaUntangle being 'too strict' against a gold standard that is itself debatable; either the true aligned accuracy is higher than reported, or the headline gain would shrink on corrected labels.
  • If these results transfer to real-world commits (which the artificial cherry-picking benchmarks only simulate), repository miners for defect prediction and bug localization could be fed cleaner atomic histories automatically, improving downstream tasks—a consequence the paper notes but does not test.
  • A cheap extension would be to make the reviewer agent aware of project-specific signals such as issue-tracker links or co-change frequency, adding a third context stream that the current framework lacks.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The manuscript proposes ColaUntangle, a multi-agent LLM framework for commit untangling. It builds a commit-level merged PDG, then derives two compressed views: Explicit Contexts (changed nodes plus shortcut edges for dependency paths) and Implicit Contexts (changed nodes plus one-hop neighbors). Two worker agents, an explicit-dependency agent and an implicit-dependency agent, produce initial groupings; a reviewer agent synthesizes them and iterates through consultation rounds until consensus or a maximum round limit. The framework is evaluated on the widely used C# dataset (1,612 tangled commits) and Java dataset (14k tangled commits), reporting Accuracy_c improvements of 44% on C# and 82% on Java over the best previous baseline, with additional ablations, a cross-LLM sensitivity study, and a manual error analysis.

Significance. If the reported gains are real, this is a substantial advance: the framework outperforms specialized heuristic, feature-based, and GNN baselines by large margins while offering an interpretable, explanation-generating architecture. The manuscript ships a public artifact link, provides a clean three-agent design with explicit/implicit context extraction, and includes an unusually candid error analysis that identifies concrete failure modes. The comparison against a single LLM is informative, and the ablation isolating the consultation mechanism is internally consistent. However, the headline empirical superiority against non-LLM baselines is not yet securely established because the evaluation uses artificial, label-noisy benchmarks and an LLM whose training data plausibly includes the public repositories used for evaluation. The central claim therefore needs additional contamination-controlled and statistically grounded evidence before the quantitative results can be taken at face value.

major comments (4)
  1. [Section 8 (External validity) and Section 4.1] The pretraining-leakage defense is too narrow. The authors argue that the risk is minimal because the datasets merge atomic commits into new tangled commits and because prompting the LLM to reproduce exact commit histories failed. This only rules out verbatim whole-commit recall; it does not rule out fragment-level recognition, where the model recognizes a known diff hunk or associates a code fragment with its original atomic commit and reconstructs concern boundaries from memory. Since the C# and Java datasets are built from public GitHub repositories that predate DeepSeek-V3's training cutoff, the reported 44% and 82% gains over HD-GNN and other non-LLM baselines are directly exposed to this contamination risk. I request a concrete test: evaluate on repositories or commits dated after the LLM's training cutoff, or inject synthetic held-out commits, or probe fragment-level memorization by asking the model to complete or attribute individual hunks. The margin over the single-LLM baseline is less suspect, but the headline comparison against non-LLM methods needs this additional evidence.
  2. [Section 6.1, Table 5] The paper's own error analysis undermines the ground truth used to compute Accuracy_c. In 17 of 50 randomly sampled misclassified cases, the dataset's 'atomic' commit actually bundles multiple unrelated activities, meaning the gold label itself is debatable. If such label noise affects a substantial fraction of the test set, then the accuracy numbers in Tables 1 and 2 are systematically biased, and some of ColaUntangle's 'errors' may be correct untanglings that disagree with a flawed annotation. The authors should quantify the proportion of test commits affected by this issue, ideally by re-annotating a random sample and reporting accuracy on a cleaned subset, and discuss how the headline improvements change under that re-annotation.
  3. [Section 5.1, Tables 1-4] All reported metrics are single point estimates with no confidence intervals, variance measures, or significance tests. Given that the datasets contain 1,612 and 14k commits, per-commit variability could be large, and the improvements over the single-LLM baselines (12 and 10 points on Accuracy_c) and especially the Accuracy_a improvements over UTango and HD-GNN (3.33% on C#) may be within noise. I recommend reporting bootstrap confidence intervals and paired significance tests (e.g., Wilcoxon signed-rank or bootstrap paired test) for the main comparisons, and reporting the distribution of per-commit accuracy rather than only the aggregate mean.
  4. [Section 4.2 and Tables 1-2] The manuscript does not state whether the baseline numbers for Barnett et al., Herzig et al., Flexeme, UTango, HD-GNN, and SmartCommit were obtained by re-running those tools with the authors' own code or were copied from prior publications. Table 1 uses '*' for unavailable per-project data points, which suggests some values come from external sources. If baselines were not rerun on the same data splits and with the same evaluation code, differences in dataset construction or metric implementation could bias the comparison. Please state the provenance of every baseline number and, where feasible, release per-commit predictions so that paired comparisons can be independently audited.
minor comments (5)
  1. [Section 4.4, footnote 4] The cost statement 'around¢2.92 per example' is ambiguous; it should read 'approximately $0.029 per example' or '2.92 cents per example'.
  2. [Throughout] There are several LaTeX spacing errors where words are joined, e.g., 'improvesBarnett et al.' and 'ColaUntangleimproves', which should be fixed in the final rendering.
  3. [Reference [34]] The author name 'Profir-Petru Pârt,achi' is garbled; it should be 'Partachi' or 'Pârţachi' with correct diacritics.
  4. [Section 2.1] The text repeatedly says 'atom commit' where 'atomic commit' is intended; this should be corrected throughout.
  5. [Section 5.1, Figures 5a-5b] The figures would be more informative with error bars or per-repository sample sizes, since repositories with very few tangled commits can produce unstable averages.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity; the central accuracy claim rests on external benchmark labels, and the only self-citation is a minor, non-load-bearing hyperparameter choice.

full rationale

The paper's load-bearing claim is the empirical superiority reported in the Abstract and Section 5.1: ColaUntangle improves Accuracy_c by 44% on the C# dataset and 82% on the Java dataset over the best baseline. The Accuracy_c metric (Section 4.3) is computed against externally constructed benchmark labels from the C# and Java datasets described in Section 4.1; no parameter is fitted to those labels. The PDG-derived Explicit and Implicit Contexts (Section 3.1) are built by a fixed algorithm with the node-matching cutoff tau=1.0 adopted from Flexeme (external prior work), and the agent prompts (Section 3.2) supply dependency heuristics, but the final partition is produced by the LLM consultation process from the diffs and contexts, not read out of any fitted equation. The central result is therefore not self-definitional and does not reduce to its inputs by construction. The only self-citation in the derivation chain is in Section 4.4, where the maximum consultation rounds t=3 is set 'aligning with ColaCare [45]', a paper coauthored by one of the current authors. This is a minor, non-load-bearing citation: the untangling output is not determined by the round cap, and the paper independently reports a 1.27-round average from a 50-commit pilot that justifies a cap of 3. No uniqueness theorem or ansatz is imported from same-author prior work. Section 8 explicitly acknowledges a pretraining-leakage threat, stating that the datasets are built from public repositories, that the risk is 'minimal', and that prompts to reproduce exact commit histories failed. That rebuttal only addresses verbatim whole-commit recall and leaves fragment-level recognition as a genuine evaluation-validity risk for the headline comparison against non-LLM baselines. This is a correctness concern, not circularity: it does not show that Accuracy_c is defined in terms of the model's inputs or that a fitted parameter was renamed as a prediction. The score is therefore 2, reflecting the single minor self-citation while affirming that the derivation chain is otherwise self-contained against external benchmarks.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

The central empirical claim rests on a hand-set graph matching threshold, a hand-set round limit, a fixed neighbor radius, and the correctness of the artificial gold labels. None of these are fitted to the test labels, so the circularity burden stays low.

free parameters (3)
  • PDG node matching fuzziness cutoff tau = 1.0
    Hand-set threshold for fuzzy matching of pre-change and post-change PDG nodes in Algorithm 1, adopted from Flexeme; affects which nodes are treated as unchanged.
  • Maximum consultation rounds t = 3
    Set after a 50-commit pilot (average 1.27 rounds) and aligned with ColaCare; bounds the iterative process and affects cost and final result.
  • Implicit context neighbor radius = 1 hop
    Algorithm 1 includes changed nodes plus their one-hop neighbors; no ablation of this radius is reported.
assumptions (5)
  • domain assumption PDGs built by Flexeme and Progex correctly encode data and control flow for the C# and Java code under analysis.
    Algorithm 1 and Section 3.1 rely on PDG edges; Section 8 acknowledges that static analysis tools can be inaccurate on complex language features.
  • domain assumption Fuzzy matching with tau=1.0 correctly aligns semantically equivalent nodes across versions.
    Algorithm 1 lines 1-8; if matching is wrong, explicit and implicit contexts misstate dependencies between changed statements.
  • domain assumption The benchmark datasets' gold concern labels are correct ground truth.
    Section 4.1 describes cherry-picking artificial tangling; Section 6.1 reports composite-commit cases where a single-concern annotation actually bundles unrelated activities.
  • domain assumption LLM agents produce structured outputs that can be reliably parsed into clusterings, agreement flags, and explanations.
    The workflow in Section 3.2 depends on parseable outputs, but no parsing validation or output schema is reported.
  • domain assumption The LLM API's stochastic outputs are stable enough for single-run evaluation.
    All experiments use default decoding; no multiple-run variance or temperature handling is reported.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LLM-Driven Collaborative Model for Untangling Commits via Explicit and Implicit Dependency Reasoning." pith.science (2026). https://pith.science/paper/AHJQEY6I

@misc{pith2026250716395,
  author       = {Pith},
  title        = {Pith review of: LLM-Driven Collaborative Model for Untangling Commits via Explicit and Implicit Dependency Reasoning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AHJQEY6I}},
  note         = {Machine review of arXiv:2507.16395}
}
read the original abstract

Atomic commits, which address a single development concern, are a best practice in software development. In practice, however, developers often produce tangled commits that mix unrelated changes, complicating code review and maintenance. Prior untangling approaches (rule-based, feature-based, or graph-based) have made progress but typically rely on shallow signals and struggle to distinguish explicit dependencies (e.g., control/data flow) from implicit ones (e.g., semantic or conceptual relationships). In this paper, we propose ColaUntangle, a new collaborative consultation framework for commit untangling that models both explicit and implicit dependencies among code changes. ColaUntangle integrates Large Language Model (LLM)-driven agents in a multi-agent architecture: one agent specializes in explicit dependencies, another in implicit ones, and a reviewer agent synthesizes their perspectives through iterative consultation. To capture structural and contextual information, we construct Explicit and Implicit Contexts, enabling agents to reason over code relationships with both symbolic and semantic depth. We evaluate ColaUntangle on two widely-used datasets (1,612 C# and 14k Java tangled commits). Experimental results show that ColaUntangle outperforms the best-performing baseline, achieving an improvement of 44% on the C# dataset and 82% on the Java dataset. These findings highlight the potential of LLM-based collaborative frameworks for advancing automated commit untangling tasks.

Figures

Figures reproduced from arXiv: 2507.16395 by the authors.

Figure 1
Figure 1. Motivating Examples containing changes related to multiple independent activities. While prior work has attempted to untangle these commits, they often fall short due to an inability to fully capture the diverse and often subtle relationships between code changes. To define the scope of the problem and motivate the design of ColaUntangle, we analyze real-world commit examples, which crystallize four critical challen… view at source ↗
Figure 2
Figure 2. Overall Workflow of ColaUntangle Our method centers on building a consolidated graph structure sensitive to code changes, followed by targeted reduction and compression. A program dependency graph (PDG) [9] is a directed graph that consists of a set of nodes N and a set of edges E, where each node n ∈ N represents a program statement or a conditional expression; and each edge e ∈ E represents the data flow or contro… view at source ↗
Figure 3
Figure 3. Code Change Example with Explicit and Implicit Contexts [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Agents in Multi-Agent Collaboration with the corresponding explicit or implicit dependency rules (concluded in Section 2.2) to guide their analysis. Each worker agent has two main functions. The first function is “untangle”. EA untangles tangled commits based on the in…
Figure 5
Figure 5. Figure 5: Average 𝐴𝑐𝑐𝑢𝑟𝑎𝑐𝑦𝑐 and Number of Changed Statements in Tangled Commits of Each Repository We also investigate the factors contributing to accuracy differences across repositories. As shown in [PITH_FULL_IMAGE:figures/full_fig_p015_5.png]
Figure 6
Figure 6. Figure 6: Examples of Error Cases Related to Fine Grouping Granularity [PITH_FULL_IMAGE:figures/full_fig_p017_6.png]
Figure 7
Figure 7. Figure 7: Examples of Error Cases Related to Coarse Grouping Granularity [PITH_FULL_IMAGE:figures/full_fig_p018_7.png]
Figure 8
Figure 8. Figure 8: Untangling Result of Different Model As shown in [PITH_FULL_IMAGE:figures/full_fig_p019_8.png]
Figure 9
Figure 9. Figure 9: Untangling Process of ColaUntangle to agree on this correct grouping. This example illustrates the combined power of our key ideas: the LLM’s superior semantic understanding, its ability to deal with cosmetic edits and other non￾functional changes, and its capacity to …

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

51 extracted references · 37 canonical work pages

  1. [1]

    Mike Barnett, Christian Bird, João Brunet, and Shuvendu K Lahiri. 2015. Helping developers help themselves: Automatic decomposition of code review changesets. In2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, Vol. 1. IEEE, 134–144. J. ACM, Vol. 37, No. 4, Article 111. Publication date: August 2018. LLM-Driven Collaborative Model ...

    work page 2015

  2. [2]

    Olga Baysal, Oleksii Kononenko, Reid Holmes, and Michael W Godfrey. 2016. Investigating technical and non-technical factors influencing modern code review.Empirical Software Engineering21, 3 (2016), 932–959

    work page 2016

  3. [3]

    Siyu Chen, Shengbin Xu, Yuan Yao, and Feng Xu. 2022. Untangling Composite Commits by Attributed Graph Clustering. InProceedings of the 13th Asia-Pacific Symposium on Internetware. 117–126

    work page 2022

  4. [4]

    Martín Dias, Alberto Bacchelli, Georgios Gousios, Damien Cassou, and Stéphane Ducasse. 2015. Untangling fine- grained code changes. In2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER). IEEE, 341–350

    work page 2015

  5. [5]

    Jinhao Dong, Yiling Lou, Qihao Zhu, Zeyu Sun, Zhilin Li, Wenjie Zhang, and Dan Hao. 2022. Fira: fine-grained graph- based code change representation for automated commit message generation. InProceedings of the 44th international conference on software engineering. 970–981

    work page 2022

  6. [6]

    Angela Fan, Beliz Gokkaya, Mark Harman, Mitya Lyubarskiy, Shubho Sengupta, Shin Yoo, and Jie M Zhang. 2023. Large language models for software engineering: Survey and open problems. In2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE). IEEE, 31–53

    2023

  7. [7]

    Lishui Fan, Jiakun Liu, Zhongxin Liu, David Lo, Xin Xia, and Shanping Li. 2025. Exploring the Capabilities of LLMs for Code-Change-Related Tasks.ACM Transactions on Software Engineering and Methodology34, 6 (2025), 1–36

    work page 2025

  8. [8]

    Mengdan Fan, Wei Zhang, Haiyan Zhao, Guangtai Liang, and Zhi Jin. 2024. Detect Hidden Dependency to Untangle Commits. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 179–190

    work page 2024

Show all 51 references
  1. [9]

    Jeanne Ferrante, Karl J Ottenstein, and Joe D Warren. 1987. The program dependence graph and its use in optimization. ACM Transactions on Programming Languages and Systems (TOPLAS)9, 3 (1987), 319–349

    1987

  2. [10]

    Verónica Uquillas Gómez, Stéphane Ducasse, and Theo d’Hondt. 2015. Visually characterizing source code changes. Science of Computer Programming98 (2015), 376–393

    2015

  3. [11]

    Bo Guo, Young-Woo Kwon, and Myoungkyu Song. 2019. Decomposing composite changes for code review and regression test selection in evolving software.Journal of Computer Science and Technology34, 2 (2019), 416–436

    2019

  4. [12]

    Bo Guo and Myoungkyu Song. 2017. Interactively decomposing composite changes to support code review and regression testing. In2017 IEEE 41st annual computer software and applications conference (COMPSAC), Vol. 1. IEEE, 118–127

    2017

  5. [13]

    Junda He, Christoph Treude, and David Lo. 2025. LLM-Based Multi-Agent Systems for Software Engineering: Literature Review, Vision, and the Road Ahead.ACM Transactions on Software Engineering and Methodology34, 5 (2025), 1–30

    2025

  6. [14]

    Steffen Herbold, Alexander Trautsch, Benjamin Ledel, Alireza Aghamohammadi, Taher A Ghaleb, Kuljit Kaur Chahal, Tim Bossenmaier, Bhaveet Nagaria, Philip Makedonski, Matin Nili Ahmadabadi, et al. 2022. A fine-grained data set and analysis of tangling in bug fixing commits.Empir...

    2022

  7. [15]

    Kim Herzig, Sascha Just, and Andreas Zeller. 2016. The impact of tangled code changes on defect prediction models. Empirical Software Engineering21 (2016), 303–336

    2016

  8. [16]

    Kim Herzig and Andreas Zeller. 2013. The impact of tangled code changes. In2013 10th Working Conference on Mining Software Repositories (MSR). IEEE, 121–130

    2013

  9. [17]

    Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. 2024. Large language models for software engineering: A systematic literature review.ACM Transactions on Software Engineering and Methodology33, 8 (2024), 1–79

    2024

  10. [18]

    Haolin Jin, Linghan Huang, Haipeng Cai, Jun Yan, Bo Li, and Huaming Chen. 2024. From llms to llm-based agents for software engineering: A survey of current, challenges and future.arXiv preprint arXiv:2408.02479(2024)

    2024 arXiv

  11. [19]

    Miryung Kim and David Notkin. 2006. Program element matching for multi-version program analyses. InProceedings of the 2006 international workshop on Mining software repositories. 58–64

    2006

  12. [20]

    Yubin Kim, Chanwoo Park, Hyewon Jeong, Yik Siu Chan, Xuhai Xu, Daniel McDuff, Hyeonhoon Lee, Marzyeh Ghassemi, Cynthia Breazeal, and Hae Won Park. 2024. MDAgents: An Adaptive Collaboration of LLMs for Medical Decision-Making. InAdvances in Neural Information Processing Systems...

    2024

  13. [21]

    Thomas N Kipf and Max Welling. 2016. Semi-supervised classification with graph convolutional networks.arXiv preprint arXiv:1609.02907(2016)

    2016 arXiv

  14. [22]

    Hiroyuki Kirinuki, Yoshiki Higo, Keisuke Hotta, and Shinji Kusumoto. 2014. Hey! are you committing tangled changes?. InProceedings of the 22nd International Conference on Program Comprehension. 262–265

    2014

  15. [23]

    Hiroyuki Kirinuki, Yoshiki Higo, Keisuke Hotta, and Shinji Kusumoto. 2016. Splitting commits via past code changes. In2016 23rd Asia-Pacific Software Engineering Conference (APSEC). IEEE, 129–136

    2016

  16. [24]

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners.Advances in neural information processing systems35 (2022), 22199–22213

    2022

  17. [25]

    Wei Le and Shannon D Pattison. 2014. Patch verification via multiversion interprocedural control flow graphs. In Proceedings of the 36th International Conference on Software Engineering. 1047–1058. J. ACM, Vol. 37, No. 4, Article 111. Publication date: August 2018. 111:24 Hou et al

    2014

  18. [26]

    Cong Li, Zhaogui Xu, Peng Di, Dongxia Wang, Zheng Li, and Qian Zheng. 2024. Understanding code changes practically with small-scale language models. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 216–228

    2024

  19. [27]

    Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. 2015. Gated graph sequence neural networks.arXiv preprint arXiv:1511.05493(2015)

    2015 arXiv

  20. [28]

    Yi Li, Shaohua Wang, and Tien N Nguyen. 2022. UTANGO: untangling commits with context-aware, graph-based, code change clustering learning model. InProceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineerin...

    2022

  21. [29]

    Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. 2024. Deepseek-v3 technical report.arXiv preprint arXiv:2412.19437(2024)

    2024 arXiv

  22. [30]

    Junwei Liu, Kaixin Wang, Yixuan Chen, Xin Peng, Zhenpeng Chen, Lingming Zhang, and Yiling Lou. 2024. Large language model-based agents for software engineering: A survey.arXiv preprint arXiv:2409.02977(2024)

    2024 arXiv

  23. [31]

    Microsoft Engineering Playbook Team. 2023. Git Guidance - Code With Engineering Playbook. https://microsoft. github.io/code-with-engineering-playbook/source-control/git-guidance/. Accessed: 2025-07-14

    2023

  24. [32]

    Emerson Murphy-Hill, Chris Parnin, and Andrew P Black. 2011. How we refactor, and how we know it.IEEE Transactions on Software Engineering38, 1 (2011), 5–18

    2011

  25. [33]

    Hoan Anh Nguyen, Anh Tuan Nguyen, and Tien N Nguyen. 2013. Filtering noise in mixed-purpose fixing commits to improve defect prediction and localization. In2013 IEEE 24th international symposium on software reliability engineering (ISSRE). IEEE, 138–147

    2013

  26. [34]

    Profir-Petru Pârt,achi, Santanu Kumar Dash, Miltiadis Allamanis, and Earl T Barr. 2020. Flexeme: Untangling commits using lexical flows. InProceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Enginee...

    2020

  27. [35]

    Achyudh Ram, Anand Ashok Sawant, Marco Castelluccio, and Alberto Bacchelli. 2018. What makes a code change easier to review: an empirical investigation on code change reviewability. InProceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference an...

    2018

  28. [36]

    Peter Rigby, Brendan Cleary, Frederic Painchaud, Margaret-Anne Storey, and Daniel German. 2012. Contemporary peer review in action: Lessons from open source development.IEEE software29, 6 (2012), 56–61

    2012

  29. [37]

    Martin P Robillard and Gail C Murphy. 2002. Concern graphs: finding and describing concerns using structural program dependencies. InProceedings of the 24th international conference on Software engineering. 406–416

    2002

  30. [38]

    Bo Shen, Wei Zhang, Christian Kästner, Haiyan Zhao, Zhao Wei, Guangtai Liang, and Zhi Jin. 2021. SmartCommit: a graph-based interactive assistant for activity-oriented commits. InProceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposiu...

    2021

  31. [39]

    Xiangru Tang, Anni Zou, Zhuosheng Zhang, Ziming Li, Yilun Zhao, Xingyao Zhang, Arman Cohan, and Mark Gerstein. 2023. Medagents: Large language models as collaborators for zero-shot medical reasoning.arXiv preprint arXiv:2311.10537(2023)

    2023 arXiv

  32. [40]

    Yida Tao, Yingnong Dang, Tao Xie, Dongmei Zhang, and Sunghun Kim. 2012. How do software engineers understand code changes? An exploratory study in industry. InProceedings of the ACM SIGSOFT 20th International symposium on the foundations of software engineering. 1–11

    2012

  33. [41]

    Yida Tao and Sunghun Kim. 2015. Partitioning composite code changes to facilitate code review. In2015 IEEE/ACM 12th Working Conference on Mining Software Repositories. IEEE, 180–190

    2015

  34. [42]

    The Linux Kernel Community. 2017. Submitting Patches: The essential guide to getting your code into the kernel. https://www.kernel.org/doc/html/v4.12/process/submitting-patches.html. Accessed: 2025-07-14

    2017

  35. [43]

    The Open Group. 2018. POSIX Base Definitions – 3.206 Character Class. https://pubs.opengroup.org/onlinepubs/ 9699919799/basedefs/V1_chap03.html#tag_03_206. Accessed: 2025-07-1

    2018

  36. [44]

    Min Wang, Zeqi Lin, Yanzhen Zou, and Bing Xie. 2019. Cora: Decomposing and describing tangled code changes for reviewer. In2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 1050–1061

    2019

  37. [45]

    Zixiang Wang, Yinghao Zhu, Huiya Zhao, Xiaochen Zheng, Dehao Sui, Tianlong Wang, Wen Tang, Yasha Wang, Ewen Harrison, Chengwei Pan, et al. 2025. Colacare: Enhancing electronic health record modeling through large language model-driven multi-agent collaboration. InProceedings o...

    2025

  38. [46]

    Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2018. How powerful are graph neural networks?arXiv preprint arXiv:1810.00826(2018)

    2018 arXiv

  39. [47]

    Sheng-Bin Xu, Si-Yu Chen, Yuan Yao, and Feng Xu. 2025. Detecting and Untangling Composite Commits via Attributed Graph Modeling.Journal of Computer Science and Technology40, 1 (2025), 119–137

    2025

  40. [48]

    Satoshi Yamashita, Shinpei Hayashi, and Motoshi Saeki. 2020. Changebeadsthreader: An interactive environment for tailoring automatically untangled changes. In2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 657–661. J. AC...

    2020

  41. [49]

    Jingfeng Yang, Hongye Jin, Ruixiang Tang, Xiaotian Han, Qizhang Feng, Haoming Jiang, Shaochen Zhong, Bing Yin, and Xia Hu. 2024. Harnessing the power of llms in practice: A survey on chatgpt and beyond.ACM Transactions on Knowledge Discovery from Data18, 6 (2024), 1–32

    2024

  42. [50]

    Yaqin Zhou, Shangqing Liu, Jingkai Siow, Xiaoning Du, and Yang Liu. 2019. Devign: Effective vulnerability identification by learning comprehensive program semantics via graph neural networks.Advances in neural information processing systems32 (2019)

    2019

  43. [51]

    Thomas Zimmermann, Andreas Zeller, Peter Weissgerber, and Stephan Diehl. 2005. Mining version histories to guide software changes.IEEE Transactions on software engineering31, 6 (2005), 429–445. Received 20 February 2007; revised 12 March 2009; accepted 5 June 2009 J. ACM, Vol....

    2005

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.