Pith. sign in

REVIEW 2 major objections 6 minor 34 references

AtomicCommitBench: Can Coding Agents Reconstruct Commit Histories from Squashed Patches?

T0 review · 2 major / 6 minor · reviewed 2026-07-12 · grok-4.5

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

Pith's one-line read Natural retrospective commit-history reconstruction is hard: agents nearly always make replayable sequences, but recover only modest human-aligned groupings, and real same-session diffs are much harder than synthetic tangles.

desk verdict Solid producer-side agent benchmark: real squashed histories are hard in a way synthetic tangles and replay checks miss, and the evidence for that claim holds. read the letter →

arxiv 2607.03332 v1 pith:WIBYPMIJ submitted 2026-07-03 cs.SE

Zhihao Lin , Mingyi Zhou , Li Li This is my paper · ORCID
classification cs.SE
keywords codingagentscommithistoryreconstructionhunkpartitioningAtomicBenchuntanglingsoftwaremaintenancereplayvalidityselectiverevert
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

Coding agents often finish a session by returning one squashed patch that mixes features, fixes, refactors, tests, and configuration. The final tree may be correct, yet the collapsed history no longer supports review, selective revert, or later recovery of complete change patterns. This paper isolates retrospective commit-history reconstruction: given only a base snapshot and a finished squashed diff, an agent must group hunks into commits and order them so every prefix applies cleanly. On AtomicCommitBench—800 real multi-commit episodes from ten Python projects—nearly all non-random methods saturate replay validity, while grouping quality against observed developer partitions stays in a wide low-to-moderate band. Matched synthetic composites are substantially easier for an untangling baseline than real same-author squashed diffs. The benchmark therefore measures the history an agent leaves behind as a property separate from final-patch correctness.

What carries the argument

Hunk-to-commit partitioning with a replay requirement: every hunk of the squashed diff is assigned to exactly one predicted commit, the number of commits is chosen by the method, and successive groups must apply without conflict from the base snapshot to the final tree. AtomicCommitBench scores outputs with PPAR (prefix replay validity), ARI (agreement with an observed developer partition), and TCR (containment of reverse-patch test failures), treating the human history as a reference rather than unique ground truth.

What would settle it

If an untangling baseline closed the reported gap and scored about as well on the real same-author episodes as on the matched synthetic composites, or if simple file-level splitting matched the best agent ARI across the full 800-episode set, the claim that natural retrospective reconstruction adds distinct difficulty would fail.

Watch

Extended reading notes

Core claim

Retrospective reconstruction of commit history from real same-session squashed patches is a distinct empirical challenge that replay checks and synthetic tangling miss. Non-random methods almost always produce sequences that apply from base to final tree, yet reference-based grouping quality ranges only from near chance to about 0.46 ARI. Real same-author episodes are markedly harder than commit-count-matched synthetic composites, and recurring agent errors are same-file lumping and support-hunk drift; dependency and hunk-role evidence helps mainly weaker setups.

Load-bearing premise

Consecutive same-author commits from mature public Python projects are treated as a fair reference for how a maintainable history should group hunks, even though several decompositions can be reasonable.

Editorial extensions

If this is right

  • Final-patch correctness alone is an incomplete score of coding-agent output; history organization is a separate measurable producer-side property.
  • Synthetic tangle constructions can overstate how cleanly systems recover natural change boundaries.
  • Dependency and hunk-role cues can reduce locality-driven grouping errors when agents over-rely on file proximity.
  • Stronger setups already produce structured draft histories that expose candidate review units beyond file-local splits.
  • Because later agents consume commit history for search and repair, producer-side organization becomes input quality for future automation.

Reading between the lines

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

  • If reconstructed histories systematically improve selective revert and bisect-style localization, teams could treat post-session split-and-order as a standard cleanup step even when the agent wrote the code incrementally.
  • The same pattern—cheap validity gate, relative reference score, optional behavioral probe—could evaluate other non-unique agent artifacts such as staged intermediate plans or multi-file review units.
  • Same-file lumping as a dominant failure mode implies that training and tooling should treat intra-file intent separation as a first-class skill rather than a side effect of path clustering.
  • A direct consumer-side test would feed reconstructed versus monolithic histories into repair or retrieval agents and measure whether the producer gains change downstream success.
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

2 major / 6 minor

Summary. The paper formalizes retrospective commit-history reconstruction: given a base snapshot and a completed squashed multi-commit diff, an agent must partition hunks into an ordered, replayable commit sequence without generating new code. It introduces AtomicCommitBench (800 stratified real same-author episodes from 10 mature Python projects) and evaluates outputs with complementary metrics—PPAR for structural replay, ARI against observed developer partitions, and TCR for selective-revert failure containment on a 151-episode modified-test slice. Diagnostic baselines, a matched synthetic-composite comparison, four model-agent setups, qualitative failure analysis (same-file lumping, support-hunk drift), and Dependency-Aware Commit Evidence (DACE) support three claims: natural reconstruction is substantially harder than replay checks or synthetic tangling; current setups produce useful draft histories with a higher ARI band for GPT-5.4/Codex and GLM-5/Claude Code; and locality-driven errors explain much of the remaining gap, with DACE helping lower-scoring setups.

Significance. If the results hold, the paper supplies a missing producer-side evaluation axis for coding agents: history organization as a measurable artifact property alongside final-patch correctness. The formalization cleanly separates history quality from code generation; the real-vs-synthetic result (+0.333 ARI for B5 on matched composites) is a concrete, falsifiable finding that challenges reliance on synthetic tangles; and the multi-metric design (PPAR/ARI/TCR) is a reusable pattern for non-unique agentic artifacts. The public benchmark and transparent setup-level reporting are practical contributions for agentic-coding evaluation. Strengths include careful non-unique-reference handling, diagnostic baselines, alternative-reference rescoring, bootstrap CIs, and Wilcoxon tests with BH correction.

major comments (2)
  1. [§3.4, §4.2, §5.3, §7] §3.4, §4.1–4.2, and §7: RQ2’s capability claims rest on comparison to lightweight heuristics (FileSplit 0.340 ARI; Untangle/B5 0.260) rather than adapted full commit-untangling systems (SmartCommit, Flexeme, UTango, Atomizer, ColaUntangle) discussed in §5.3. Without at least one strong specialized baseline that also selects commit count and enforces replay, it is hard to interpret whether best-agent ARI ≈0.46 reflects agent limits, task hardness, or simply the absence of purpose-built methods. Either adapt one system with commit-count selection and replay repair, or narrow the RQ2 claim to “relative to simple locality/dependency heuristics and current coding-agent harnesses.”
  2. [§3.5, §4.2, Abstract, §8] §3.5 and Observation RQ2: The headline ranking places GPT-5.4 (Codex CLI) with GLM-5/Kimi/MiniMax (Claude Code routing). The paper correctly labels these as model-agent setups, but the cross-band separation used in the abstract and conclusion still confounds model and harness. The same-harness ordering (GLM-5 > MiniMax > Kimi) is the cleaner capability signal; the manuscript should state primary conclusions from harness-matched comparisons and treat the GPT-5.4 row as a separate setup snapshot, not as part of a single model ranking.
minor comments (6)
  1. [§3.3, Abstract, Observation RQ2] §3.3: TCR is defined only on 151 scoreable modified-test episodes. The paper is transparent, but the abstract and Observation RQ2 should more explicitly flag TCR as a partial probe so readers do not treat the 0.917/0.871/… numbers as full-benchmark scores.
  2. [§3.2, Table 1] §3.2 / Table 1: Difficulty tiers oversample Medium relative to the candidate pool. The note that re-weighting does not change ranking is helpful; consider reporting the re-weighted ARI means in an appendix for completeness.
  3. [§3.4, §4.3] §3.4: DACE is evaluated only as a combined package (+T). A one-sentence note that dependency-only vs. profiler-only ablations are left to future work would prevent over-reading the causal role of each cue type.
  4. [Figure 2] Figure 2: The ARI ranking mixes baselines, model-agent setups, and +DACE runs in one list. A small visual grouping or facet (as the legend suggests) would make the three comparison classes easier to read at a glance.
  5. [§2.2] §2.2 Definition 2: Replay validity is defined via conflict-free prefix application. Briefly state whether empty intermediate trees, binary-adjacent edge cases, or rename/mode changes are in scope, since Git apply behavior can differ from full commit replay.
  6. [References] References: arXiv-only and concurrent agent papers are fine for a preprint, but ensure final citation keys and venue status are updated for any accepted versions of SWE-bench variants and untangling systems before camera-ready.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: empirical agent evaluation with held-out human partitions, independent structural/behavioral metrics, and no fitted-input-as-prediction or self-citation load-bearing chain.

full rationale

AtomicCommitBench is an empirical SE benchmark paper, not a first-principles derivation. The central difficulty claim (natural retrospective reconstruction harder than replay checks or matched synthetic tangles) is measured by applying the same methods to held-out inputs: agents receive only the squashed diff and base snapshot, never original boundaries, messages, or intermediate states (Sec. 3.1, 3.5–3.6). PPAR is a structural apply-rate over predicted prefixes; ARI compares predicted hunk partitions to observed developer partitions as a relative reference signal the paper explicitly does not treat as unique ground truth (Def. 2, Sec. 2.2, 3.3); TCR is a label-free reverse-patch test-containment probe on a 151-episode slice. The synthetic-vs-real gap (+0.333 ARI for B5) uses commit-count-matched composites with the same baseline and true k on both sides (Fig. 3)—boundary separability, not a fit renamed as prediction. DACE supplies soft dependency/role evidence without leaking reference labels (Sec. 3.4). No self-definitional loop, no parameter fitted then re-predicted, no uniqueness theorem imported from overlapping authors, and no ansatz smuggled via self-citation. Dual use of human consecutive-commit histories as both episode filter and ARI reference is a construct-validity choice the paper already flags (Sec. 7), not circularity of the evaluation chain. Score 0 is the honest finding.

Assumptions & free parameters 6 free parameters · 5 assumptions · 4 invented entities

This is an empirical SE benchmark paper, not a first-principles derivation. The load-bearing commitments are dataset construction choices and the decision to treat human consecutive commits as a relative reference for non-unique histories. Free parameters are mostly sampling and filtering thresholds. Invented entities are the benchmark, the DACE evidence package, and the paper-specific metrics PPAR/TCR layered on standard ARI.

free parameters (6)
  • same-author time window
    Adjacent commits must be at most 48 hours apart; this hand-chosen window defines which runs count as coherent episodes.
  • commit-count filter
    Only runs with 2 to 8 commits are kept; longer runs are discarded rather than split.
  • diff-size filter
    Diffs smaller than 20 or larger than 2,000 lines are excluded from candidates.
  • difficulty tier thresholds
    Easy/Medium/Hard cutoffs use commit counts and changed-line budgets (e.g., <=3 commits and 200 lines; <=5 commits and 600 lines).
  • evaluation sample composition
    800 episodes sampled with seed 42 as 320 Easy / 320 Medium / 160 Hard, oversampling Medium relative to the raw pool.
  • agent turn budget
    LLM agents are limited to at most 50 turns under one prompt and one run per episode.
assumptions (5)
  • domain assumption Human-maintained consecutive commits in mature public Python projects provide a useful relative reference for maintainable hunk groupings, even though multiple decompositions can be reasonable.
    Stated throughout Sections 2-3 and 7; ARI depends on this reference choice.
  • domain assumption Same-author plus short time-window constraints approximate coherent development/cleanup sessions without issue metadata.
    Section 3.1 uses this to justify episode mining and reduce unrelated multi-task joins.
  • domain assumption Hunks are an adequate prediction unit for commit reconstruction despite rare multi-commit hunks (2.3%).
    Section 3.3 and Threats; rankings unchanged on the clean subset, but the representation is still lossy in principle.
  • ad hoc to paper Replay validity, reference ARI, and selective-revert test containment jointly measure history quality without requiring a unique semantic ground truth.
    Core measurement design in Sections 2.2 and 3.3; necessary because the paper rejects a single hard semantic-validity rule.
  • standard math Adjusted Rand Index is an appropriate dataset-level relative grouping score when order and labels are ignored.
    Standard clustering agreement metric (Hubert & Arabie 1985), used as relative signal only.
invented entities (4)
  • AtomicCommitBench independent evidence
    purpose: Provide 800 real retrospective reconstruction episodes with held-out human reference partitions and complementary metrics.
    Primary artifact of the paper; independent evidence is limited to the public GitHub claim and described construction process.
  • PPAR (prefix-patch apply rate) independent evidence
    purpose: Score structural replay validity of predicted commit prefixes.
    Paper-specific structural gate; falsifiable by replaying predicted patch sequences.
  • TCR (test-failure containment rate) independent evidence
    purpose: Label-free probe of whether predicted commits localize behavioral breakage under reverse patches.
    Paper-specific partial probe on 151 scoreable episodes; not a full revert/merge semantics check.
  • DACE (Dependency-Aware Commit Evidence)
    purpose: Supply soft dependency edges and hunk-role warnings to reduce locality-driven grouping errors.
    Tool package introduced for RQ3; gains are setup-specific and lack component ablations.

how reviews work

0 comments
Cite this review

Pith. "Pith review of AtomicCommitBench: Can Coding Agents Reconstruct Commit Histories from Squashed Patches?." pith.science (2026). https://pith.science/paper/WIBYPMIJ

@misc{pith2026260703332,
  author       = {Pith},
  title        = {Pith review of: AtomicCommitBench: Can Coding Agents Reconstruct Commit Histories from Squashed Patches?},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WIBYPMIJ}},
  note         = {Machine review of arXiv:2607.03332}
}
read the original abstract

Coding agents often finish a session by returning one squashed patch that mixes feature implementation, bug fixes, refactorings, tests, and configuration edits. While the final code may be correct, collapsing unrelated edits into one patch removes the history structure needed for review, selective revert, and later maintenance. We study retrospective commit-history reconstruction: given a completed squashed change, an agent groups its hunks into commits and materializes a replayable commit sequence. We formalize the task as hunk-to-commit partitioning with a replay requirement and build AtomicCommitBench, containing 800 real consecutive-commit episodes from 10 Python projects. Because multiple decompositions may be reasonable, we evaluate outputs using complementary metrics: PPAR for replay validity, ARI for reference-based grouping quality, and TCR for failure containment on scoreable modified-test episodes. Natural retrospective reconstruction proves substantially harder than replay checking or synthetic tangling. Although nearly all non-random methods achieve replay validity (PPAR >= 0.988), grouping quality ranges from 0.03 to 0.46 ARI. Matched synthetic composites are much easier than real same-author squashed diffs (+0.333 ARI). In our evaluation, the GPT-5.4 setup driven by Codex CLI (0.46 ARI) and the GLM-5 setup driven by Claude Code (0.43 ARI) outperform MiniMax (0.31) and Kimi (0.29). Qualitative analysis identifies same-file lumping and support-hunk drift as recurring failure modes. Dependency-Aware Commit Evidence (DACE) improves the lower-scoring setups by 0.05 to 0.08 ARI, indicating that dependency cues and hunk-role information help agents avoid locality-driven grouping errors. AtomicCommitBench enables evaluation of the commit histories produced by coding agents alongside the final code.

Figures

Figures reproduced from arXiv: 2607.03332 by the authors.

Figure 1
Figure 1. Overview of retrospective commit-history reconstruction. Given a base repository snapshot [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Main grouping results on 800 natural retrospective episodes. Points report ARI against [PITH_FULL_IMAGE:figures/full_fig_p009_2.png] view at source ↗
Figure 3
Figure 3. B5 ARI on synthetic composites versus real squashed diffs, matched by observed commit [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Selective-revert containment on the 151-episode common scoreable slice. Easy Medium Hard 0.10 0.15 0.20 0.25 0.30 0.35 0.40 0.45 0.50 ARI GPT-5.4 GLM-5 FileSplit MiniMax Untangle Kimi ARI by episode difficulty [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]
Figure 6
Figure 6. Figure 6: An anonymized representative reconstruction case. The squashed diff interleaves a timeout [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 6 linked inside Pith

  1. [1]

    SWE-bench: Can language models resolve real-world GitHub issues?

    C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan, “SWE-bench: Can language models resolve real-world GitHub issues?” inProc. ICLR, 2024. 17 AtomicCommitBench Preprint

    2024

  2. [2]

    Introducing SWE-bench verified,

    N. Chowdhury, J. Aung, J. S. Chan, O. Jaffe, D. Sherburn, G. Starace, E. Mays, R. Dias, M. Aljubeh, M. Glaese, C. E. Jimenez, J. Yang, L. Ho, T. Patwardhan, K. Liu, and A. Madry, “Introducing SWE-bench verified,” https://openai.com/index/introducing-swe-bench-verified/, 2024

    2024

  3. [3]

    Multi-SWE-bench: A multilingual benchmark for issue resolving,

    D. Zan, Z. Huang, W. Liu, H. Chen, L. Zhang, S. Xin, L. Chen, Q. Liu, X. Zhong, A. Li, S. Liu, Y. Xiao, L. Chen, Y. Zhang, J. Su, T. Liu, R. Long, K. Shen, and L. Xiang, “Multi-SWE-bench: A multilingual benchmark for issue resolving,”arXiv:2504.02605, 2025

    arXiv 2025

  4. [4]

    SWE-bench goes live!

    L. Zhang, S. He, C. Zhang, Y. Kang, B. Li, C. Xie, J. Wang, M. Wang, Y. Huang, S. Fu, E. Nal- lipogu, Q. Lin, Y. Dang, S. Rajmohan, and D. Zhang, “SWE-bench goes live!”arXiv:2505.23419, 2025

    arXiv 2025

  5. [5]

    The effects of change decomposition on code review—a controlled experiment,

    M. di Biase, M. Bruntink, A. Bacchelli, and A. van Deursen, “The effects of change decomposition on code review—a controlled experiment,”PeerJ Computer Science, vol. 5, p. e193, 2019, arXiv:1805.10978

    arXiv 2019

  6. [6]

    The impact of tangled code changes on defect prediction models,

    K. Herzig, S. Just, and A. Zeller, “The impact of tangled code changes on defect prediction models,”Empirical Software Engineering, vol. 21, no. 2, pp. 303–336, 2016

    2016

  7. [7]

    Code researcher: Deep research agent for large systems code and commit history,

    R. Singh, S. Joel, A. Mehrotra, N. Wadhwa, R. B. Bairi, A. Kanade, and N. Natarajan, “Code researcher: Deep research agent for large systems code and commit history,”arXiv preprint arXiv:2506.11060, 2025

    arXiv 2025

  8. [8]

    HAFixAgent: History-aware program repair agent,

    Y. Shi, H. Li, B. Adams, and A. E. Hassan, “HAFixAgent: History-aware program repair agent,” arXiv preprint arXiv:2511.01047, 2025

    arXiv 2025

Show all 34 references
  1. [9]

    Lore: Repurposing git commit messages as a structured knowledge protocol for AI coding agents,

    I. Stetsenko, “Lore: Repurposing git commit messages as a structured knowledge protocol for AI coding agents,”arXiv preprint arXiv:2603.15566, 2026

    2026

  2. [10]

    A fine-grained data set and analysis of tangling in bug fixing commits,

    S. Herbold, A. Trautsch, F. Trautsch, B. Ledel, A. Aghamohammadi, T. Ahlbrecht, M. Aslan, B. Caglayan, S. Cattes, M. Dybaet al., “A fine-grained data set and analysis of tangling in bug fixing commits,”Empirical Software Engineering, vol. 27, no. 1, pp. 1–43, 2022

    2022

  3. [11]

    SmartCommit: A graph-based interactive assistant for activity-oriented commits,

    B. Shen, W. Zhang, C. Kästner, H. Zhao, Z. Wei, G. Liang, and Z. Jin, “SmartCommit: A graph-based interactive assistant for activity-oriented commits,” inProc. ESEC/FSE, 2021, pp. 379–390

    2021

  4. [12]

    Flexeme: Untangling commits using lexical flows,

    P.-P. Pârţachi, S. K. Dash, M. Allamanis, and E. T. Barr, “Flexeme: Untangling commits using lexical flows,” inProc. ESEC/FSE, 2020, pp. 63–74

    2020

  5. [13]

    UTANGO: Untangling commits with context-aware, graph-based, code change clustering learning model,

    Y. Li, S. Wang, and T. N. Nguyen, “UTANGO: Untangling commits with context-aware, graph-based, code change clustering learning model,” inProc. ESEC/FSE, 2022

    2022

  6. [14]

    PyDriller: Python framework for mining software repositories,

    D. Spadini, M. Aniche, and A. Bacchelli, “PyDriller: Python framework for mining software repositories,” inProc. ESEC/FSE, 2018, pp. 908–911

    2018

  7. [15]

    Comparing partitions,

    L. Hubert and P. Arabie, “Comparing partitions,”Journal of Classification, vol. 2, no. 1, pp. 193–218, 1985

    1985

  8. [16]

    Individual comparisons by ranking methods,

    F. Wilcoxon, “Individual comparisons by ranking methods,”Biometrics Bulletin, vol. 1, no. 6, pp. 80–83, 1945. 18 AtomicCommitBench Preprint

    1945

  9. [17]

    Controlling the false discovery rate: A practical and powerful approach to multiple testing,

    Y. Benjamini and Y. Hochberg, “Controlling the false discovery rate: A practical and powerful approach to multiple testing,”Journal of the Royal Statistical Society: Series B (Methodological), vol. 57, no. 1, pp. 289–300, 1995

    1995

  10. [18]

    SWE-agent: Agent-computer interfaces enable automated software engineering,

    J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “SWE-agent: Agent-computer interfaces enable automated software engineering,” inProc. NeurIPS, 2024

    2024

  11. [19]

    AutoCodeRover: Autonomous program improvement,

    Y. Zhang, H. Ruan, Z. Fan, and A. Roychoudhury, “AutoCodeRover: Autonomous program improvement,” inProc. ISSTA, 2024, pp. 1592–1604

    2024

  12. [20]

    GitGoodBench: A novel benchmark for evaluating agentic performance on Git,

    T. Lindenbauer, E. Bogomolov, and Y. Zharov, “GitGoodBench: A novel benchmark for evaluating agentic performance on Git,” inREALM@ACL, 2025, pp. 272–288. [Online]. Available: https://aclanthology.org/2025.realm-1.19/

    2025

  13. [21]

    EditFlow: Benchmarking and optimizing code edit recommendation systems via reconstruction of developer flows,

    C. Liu, Y. Lin, J. Chang, J. Liu, B. Qi, B. Jiang, Z. Huang, and J. S. Dong, “EditFlow: Benchmarking and optimizing code edit recommendation systems via reconstruction of developer flows,” inProc. OOPSLA, 2026

    2026

  14. [22]

    SWE-EVO: Benchmark- ing coding agents in long-horizon software evolution scenarios,

    T. Le, M. V. T. Thai, D. Nguyen Manh, H. N. Phan, and N. D. Q. Bui, “SWE-EVO: Benchmark- ing coding agents in long-horizon software evolution scenarios,”arXiv preprint arXiv:2512.18470, 2025

    2025 arXiv

  15. [23]

    AgentPack: A dataset of code changes, co-authored by agents and humans,

    Y. Zi, Z. Wu, A. Boruch-Gruszecki, J. Bell, and A. Guha, “AgentPack: A dataset of code changes, co-authored by agents and humans,”arXiv:2509.21891, 2025

    2025

  16. [24]

    Code change characteristics and description alignment: A comparative study of agentic versus human pull requests,

    D. Pham and T. A. Ghaleb, “Code change characteristics and description alignment: A comparative study of agentic versus human pull requests,”arXiv preprint arXiv:2601.17627, 2026

    2026

  17. [25]

    Detecting multiple semantic concerns in tangled code commits,

    B. Koh, N. Walkinshaw, and D. Shin, “Detecting multiple semantic concerns in tangled code commits,”arXiv preprint arXiv:2601.21298, 2026

    2026

  18. [26]

    Helping developers help themselves: Automatic decomposition of code review changesets,

    M. Barnett, C. Bird, J. Brunet, and S. K. Lahiri, “Helping developers help themselves: Automatic decomposition of code review changesets,” inProc. ICSE, 2015, pp. 134–144

    2015

  19. [27]

    Peer review on open-source software projects: Parameters, statistical models, and theory,

    P. C. Rigby, D. M. German, L. Cowen, and M.-A. Storey, “Peer review on open-source software projects: Parameters, statistical models, and theory,”ACM TOSEM, vol. 23, no. 4, pp. 1–33, 2014

    2014

  20. [28]

    Code reviewing in the trenches: Challenges and best practices,

    L. MacLeod, M. Greiler, M.-A. Storey, C. Bird, and J. Czerwonka, “Code reviewing in the trenches: Challenges and best practices,”IEEE Software, vol. 35, no. 4, pp. 34–42, 2018

    2018

  21. [29]

    CommitBench: A benchmark for commit message generation,

    M. Schall, T. Czinczoll, and G. de Melo, “CommitBench: A benchmark for commit message generation,” inProc. SANER, 2024

    2024

  22. [30]

    From commit message generation to history-aware commit message completion,

    A. Eliseeva, Y. Sokolov, E. Bogomolov, Y. Golubev, D. Dig, and T. Bryksin, “From commit message generation to history-aware commit message completion,” inProc. ASE, 2023

    2023

  23. [31]

    RAG-enhanced commit message generation,

    L. Zhang, H. Zhang, C. Wang, and P. Liang, “RAG-enhanced commit message generation,” arXiv:2406.05514, 2024. 19 AtomicCommitBench Preprint

    2024 arXiv

  24. [32]

    Only diff is not enough: Generating commit messages leveraging reasoning and action of large language model,

    J. Li, D. Faragó, C. Petrov, and I. Ahmed, “Only diff is not enough: Generating commit messages leveraging reasoning and action of large language model,”Proceedings of the ACM on Software Engineering, vol. 1, no. FSE, pp. 745–766, 2024

    2024

  25. [33]

    Atomizer: An LLM-based collaborative multi-agent framework for intent-driven commit untangling,

    K. Zhu, Z. Tian, S. Wang, M. Leng, and X. Mao, “Atomizer: An LLM-based collaborative multi-agent framework for intent-driven commit untangling,”arXiv:2601.01233, 2026

    2026

  26. [34]

    LLM-driven collaborative model for untangling commits via explicit and implicit dependency reasoning,

    B. Hou, X. Tan, K. Zheng, F. Liu, Y. Zhu, and L. Zhang, “LLM-driven collaborative model for untangling commits via explicit and implicit dependency reasoning,”arXiv preprint arXiv:2507.16395, 2025. 20

    2025

Pith tools

Reviewed July 12, 2026 · model on record in the stance chip above.