Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

UserTrace contends that a software repository alone carries enough signal to reconstruct the user-level requirements behind it and to trace those requirements down to the implementing code.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

UserTrace generates user-level requirements from code repositories and recovers live trace links from requirements to implementation, with evaluations suggesting gains over summarization and traceability baselines.

T0 review reviewed 2026-08-04 challenge →

load-bearing objection Genuinely new task and a sensible pipeline, but the 'superior precision' claim is contradicted by the paper's own Table 3 and the RQ2 metric needs a link-level re-evaluation. the 4 major comments →

arxiv 2509.11238 v1 pith:2WZTVINO submitted 2025-09-14 cs.SE

UserTrace: User-Level Requirements Generation and Traceability Recovery from Software Project Repositories

Dongming Jin , Zhi Jin , Yiran Zhang , Zheng Fang , Linyu Li , Yuanpeng He , Xiaohong Chen , Weisong Sun This is my paper
classification cs.SE
keywords user requirements generationrequirements traceabilitymulti-agent LLM systemsrepository understandinguse case modelingtrace link recoveryAI-assisted software developmentcode summarization
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The reading

UserTrace claims that a software repository alone contains enough signal to reconstruct the user-level requirements a system was built to satisfy, and to wire those requirements to the code that implements them. The paper argues that existing code summarization stays at the implementation level and existing traceability tools ignore project evolution, leaving end users without a stable requirements view of AI-generated software. The proposed multi-agent system parses the repository into dependency graphs, derives implementation-level requirements for each code unit, then abstracts groups of those requirements into use-case-style user requirements using retrieved domain business knowledge and iterative verification. A comparative evaluation reports higher completeness, correctness, and helpfulness of generated requirements than a baseline, and precision in trace-link recovery that beats five state-of-the-art approaches. A small user study reports faster and more accurate validation of AI-generated repositories with the tool.

Core claim

The paper's central discovery is that user intent, though not written anywhere in the code, can be recovered through a controlled abstraction chain: static analysis converts a repository into a component-level and file-level dependency graph; a code-reviewer agent writes implementation-level requirements for each unit in topological order; community detection groups files into functional clusters; a writer agent lifts each cluster's implementation requirements into a user-level requirement expressed as a use case (name, actors, description, preconditions, event flow, exit conditions), enriched with domain business knowledge retrieved from the web; and a verifier agent loops feedback until co

What carries the argument

The load-bearing mechanism is the dual-level dependency graph (component-level and file-level) built by static abstract-syntax-tree analysis, which gives a topological processing order so each code unit is summarized with only its direct dependencies in context. Around that core, four specialized agents collaborate: the Code Reviewer derives implementation-level requirements; the Searcher fetches missing domain business knowledge from the open internet; the Writer abstracts implementation requirements into user-level use cases after community detection groups related files; and the Verifier scores the result on completeness, business-context value, and detail level, sending structured feedba

Load-bearing premise

User intent can be recovered from source code plus generic web business knowledge, even when the true rationale for the system lives outside the repository.

What would settle it

Run UserTrace on a set of repositories whose user-facing requirements are independently documented and whose names and comments have been systematically obfuscated to remove intent signals; if the generated use cases then match the true requirements only at chance level, the recovery claim fails. Alternatively, a longitudinal check: modify the code in a way that changes user-visible behavior and verify that regenerated user requirements reflect the change.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • AI-generated repositories can be validated by end users against their intent without hand-written requirements documents, since the requirements view is produced on demand.
  • Trace links run from user-level requirements down to file- and component-level requirements to code, giving maintainers a stable abstraction layer for impact analysis and update propagation.
  • The pipeline is model-agnostic: the reported gains hold across three different large language model families, with the strongest model achieving the best scores.
  • The generated use-case requirements can double as ground-truth candidates for building or expanding requirements-engineering datasets, reducing data scarcity in traceability research.
  • The cost of the extra fidelity is measurable: runtime rises by roughly 30–50% and token usage by 60–80% compared with the hierarchical summarization baseline, still within practical offline use.

Where Pith is reading between the lines

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

  • A natural test no reported experiment covers is whether the recovered requirements track a repository across commits; the 'live' claim invites a longitudinal study where code changes and the regenerated user requirements should shift accordingly.
  • The reliance on open-internet business knowledge suggests the approach may degrade exactly where it is most needed: proprietary business logic whose rationale exists only in internal documents and product decisions.
  • Because evaluation rests on three known systems plus a three-participant user study, scaling to a larger, heterogeneous sample of real projects would be needed to know whether the precision advantage generalizes.
  • If the method is applied to generated code with arbitrary naming and no underlying design, the hallucination failure mode the authors observed in raw models may reappear in a subtler form; an adversarial naming experiment would expose this.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes UserTrace, a multi-agent system that takes a software repository as input and generates user-level requirements (URs) in use-case format together with trace links from URs to implementation-level requirements (IRs) and code. The approach has three phases: repository structuring via dual-level dependency graphs, IR derivation with a Code Reviewer agent, and UR synthesis with Searcher/Writer/Verifier agents, including domain-knowledge retrieval and iterative verification. The evaluation uses three CoEST systems (eTour, eAnci, SMOS), three LLMs (GPT-4, Claude 3, DeepSeek R1), a hierarchical-summarization baseline for UR generation, five RT baselines (VSM, LSI, COMET, FTLR, LiSSA) for trace recovery, and a three-participant user study. The main claims are that UserTrace produces more complete, correct, and helpful URs than the baseline, achieves superior precision in trace-link recovery, and helps end users validate AI-generated repositories.

Significance. If the claims are supported, the work addresses a real gap: existing code summarization operates at implementation level, and requirements traceability typically assumes requirements already exist. UserTrace's idea of recovering user-facing requirements from code plus external business knowledge is timely for AI-generated software validation and maintenance. The architecture, with role-specialized agents and a verify-then-feedback loop, is reasonable, and the evaluation uses standard traceability datasets and several baselines. However, the strongest quantitative claims are currently not fully supported by the presented evidence. In particular, the trace-recovery superiority claim is contradicted by the paper's own Table 3 on one dataset, and the adopted group-based correctness criterion may favor the proposed coarse-grained links over fine-grained baselines. The UR-quality assessment relies on LLM-as-a-judge with no human agreement check. The 'live trace links' claim is not tested at all. These issues are addressable, but they are load-bearing for the abstract's central claims.

major comments (4)
  1. [Abstract; §5.2, Table 3] The abstract claims UserTrace 'achieves superior precision in trace link recovery compared to five state-of-the-art RT approaches.' Table 3 does not support this unqualified statement. On SMOS, FTLR has P_TL=0.190 and F1_TL=0.191, while the best UserTrace row (GPT-4) has P_TL=0.140 and F1_TL=0.146. The RQ2 answer itself is more cautious, saying 'comparable or superior.' The claim should be restricted to the datasets and metrics where it actually holds, and the SMOS failure should be discussed.
  2. [§4.3, Eq. (2)] The trace-link evaluation depends on a group-based correctness rule with Jaccard overlap threshold theta=0.5. No justification or sensitivity analysis for theta is provided. This metric structurally rewards coarse-grained generated links: UserTrace generates URs per Leiden community and links them to broad file/component sets, whereas baselines such as FTLR produce fine-grained method-level links. A generated link whose code set overlaps half of a ground-truth set is counted correct, while a precise method-level link may obtain a low Jaccard score. The comparison is therefore not apples-to-apples. Please report link-level precision/recall (or a link-level mapping), evaluate at multiple theta values, and show how the baselines perform under the same grouping and thresholding conventions.
  3. [§4.3; §5.1, Table 2] The document-level UR quality scores (Completeness, Correctness, Helpfulness) are produced by G-Eval, an LLM-as-a-judge, with no human agreement study and without the judge prompt being included. Since both the generated URs and the judge are LLM outputs, self-preference cannot be ruled out. The set-level P/R/F1 scores are described as manually evaluated, but the matching protocol and inter-rater reliability are not reported. Please add a human evaluation of a sample of URs, release the judge prompt, or clearly label the LLM-judged scores as exploratory rather than definitive evidence for the quality claim.
  4. [§1; §3.1; §7.2] The paper repeatedly emphasizes 'live trace links' and claims in §7.2 that 'the trace links it generates can evolve alongside the system.' However, all RQ2 experiments use static repository snapshots; there is no evolution scenario, no version change, and no measurement of link update or decay. The 'live' property is therefore untested. Either add an experiment where the repository changes and trace links are re-recovered/maintained, or revise the terminology and claims to describe static recovery only.
minor comments (5)
  1. [§4.4; §8] Table 1 includes iTrust, but no experimental results are reported for it, while the conclusion says 'Experiments on four real-world systems.' Please align the dataset list with the experiments actually reported, or include iTrust results.
  2. [§4.1; §5.3] The user study has only three participants, all experienced developers using AI-assisted tools; this is a small convenience sample, not representative of 'end users with limited programming expertise.' The claim should be softened or the sample expanded.
  3. [§4.3] Equation (3) defines R_TL as |Link_gen^correct| / |Link_gt|. Since several generated links can overlap the same ground-truth set, recall can exceed 1 in principle. Please clarify the denominator and how duplicate or overlapping links are handled.
  4. [§3.3; §3.4; §4.4; §6.2] There are various typos and unfinished references, including 'foudation' (§3.3), 'Writter' (§3.4), 'constrast' (§4.4), 'Treat' (§6.2), and empty citations 'ChatGPT [] and Claude []' in §7.1. The manuscript should be proofread.
  5. [§4.2] The text says GPT-4 but the used model is 'gpt-4o-2024-05-13'; please use consistent naming so results are reproducible. The same applies to Claude 3 model versions.

Circularity Check

0 steps flagged

No significant circularity: outputs are not defined in terms of evaluation targets; remaining concerns are metric-validity issues.

full rationale

The derivation chain is self-contained. UserTrace generates IRs from repository code via dependency graphs, then groups files with Leiden community detection, and finally synthesizes URs from each community's IRs plus external business knowledge. The trace links are the community-to-file assignments that are compared against CoEST ground truth; the generation process does not use the ground-truth links or the RQ2 correctness rule as inputs. The group-based correctness rule in Eq. (2) is an evaluation metric, not a fitted parameter, so the performance claim is not forced by construction, although its coarse-grain preference is a validity concern. The RQ1 LLM-as-a-judge (G-Eval) evaluation is explicitly acknowledged in Section 6.2 as prompt-sensitive, and it is partly an internal check; however, RQ1 also includes a manual set-based precision/recall/F1 evaluation, and RQ2 uses external CoEST ground truth, providing independent evidence. The paper's self-citations (MARE, iReDev, etc.) are background references and are not load-bearing for the central derivation or evaluation. The 'live trace links' claim is not experimentally demonstrated (all datasets are snapshots), but that is a missing-evidence/correctness issue, not circularity. Overall, no step reduces to its own input by definition or self-citation.

Axiom & Free-Parameter Ledger

2 free parameters · 6 axioms · 0 invented entities

The central claim rests on domain assumptions about the recoverability of user intent from code plus web knowledge, the adequacy of use cases as UR representations, and the validity of LLM-based and custom group-based evaluation. No new physical or conceptual entities are postulated beyond software components; UserTrace's agents are ordinary modules. The only explicit hand-set numeric parameter is the trace threshold, with baseline thresholds optimized per project.

free parameters (2)
  • Trace correctness threshold theta = 0.5
    Equation (2) defines a generated link as correct only if the Jaccard overlap between generated and ground-truth code sets is at least 0.5. This value is chosen by hand and every reported trace precision, recall, and F1 depends on it.
  • Project-optimized cutoff for VSM and LSI baselines = per-dataset optimal F1 threshold
    Section 6.2 says the baseline threshold was varied to report the upper boundary of achievable performance. This is a free parameter fit to each test project, making the comparison setting different from standard RT evaluation.
axioms (6)
  • domain assumption Repositories contain implicit signals of user intent sufficient to reconstruct URs.
    Section 2.2 states that code repositories encode implicit user intent that can be extracted and abstracted. If false, the entire pipeline cannot produce faithful user-level requirements.
  • domain assumption Use cases are a sufficient representation of user-level requirements.
    Section 2.1 adopts use cases as the target format for URs. This choice shapes generation and evaluation; other formats could lead to different results.
  • domain assumption LLM-as-a-judge (G-Eval) scores approximate human judgments of completeness, correctness, and helpfulness.
    Section 4.3 uses G-Eval scores as the main document-level quality metric for RQ1 without human validation on the evaluated systems.
  • ad hoc to paper Group-based link correctness with Jaccard overlap at least 0.5 captures correct trace recovery.
    Equation (2) defines a custom evaluation rule because generated URs are not identical to ground-truth requirements. The threshold is not derived or validated.
  • domain assumption Ground-truth trace links in the CoEST datasets are reliable anchors for evaluating links from generated URs.
    Section 4.4 uses eTour, eAnci, and SMOS ground-truth links as reference sets, assuming they are correct and stable.
  • domain assumption The Searcher's open-internet retrieval supplies correct and relevant business knowledge.
    Section 3.4 relies on web retrieval to fill missing business context; the paper does not audit the retrieved knowledge or measure retrieval errors.

reviewed 2026-08-04 · how reviews work

0 comments
Cite this review

Pith. "Pith review of UserTrace: User-Level Requirements Generation and Traceability Recovery from Software Project Repositories." pith.science (2026). https://pith.science/paper/2WZTVINO

@misc{pith2026250911238,
  author       = {Pith},
  title        = {Pith review of: UserTrace: User-Level Requirements Generation and Traceability Recovery from Software Project Repositories},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2WZTVINO}},
  note         = {Machine review of arXiv:2509.11238}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Software maintainability critically depends on high-quality requirements descriptions and explicit traceability between requirements and code. Although automated code summarization (ACS) and requirements traceability (RT) techniques have been widely studied, existing ACS methods mainly generate implementation-level (i.e., developer-oriented) requirements (IRs) for fine-grained units (e.g., methods), while RT techniques often overlook the impact of project evolution. As a result, user-level (i.e., end user-oriented) requirements (URs) and live trace links remain underexplored, despite their importance for supporting user understanding and for validating whether AI-generated software aligns with user intent. To address this gap, we propose UserTrace, a multi-agent system that automatically generates URs and recovers live trace links (from URs to IRs to code) from software repositories. UserTrace coordinates four specialized agents (i.e., Code Reviewer, Searcher, Writer, and Verifier) through a three-phase process: structuring repository dependencies, deriving IRs for code units, and synthesizing URs with domain-specific context. Our comparative evaluation shows that UserTrace produces URs with higher completeness, correctness, and helpfulness than an established baseline, and achieves superior precision in trace link recovery compared to five state-of-the-art RT approaches. A user study further demonstrates that UserTrace helps end users validate whether the AI-generated repositories align with their intent.

Figures

Figures reproduced from arXiv: 2509.11238 by Dongming Jin, Linyu Li, Weisong Sun, Xiaohong Chen, Yiran Zhang, Yuanpeng He, Zheng Fang, Zhi Jin.

Figure 1
Figure 1. Figure 1: Three illustrative cases comparing GPT-4 generated requirements with ideal URs. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: An Example of Use Case from the School Student Monitoring System (SMOS) [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: An Example Demonstrating the Relationship Between Source Code, IRs, and URs [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Overview of our UserTrace. This dual-layer dependency graph representation provides the foundation for subsequent phases. The CDG (or FDG) provides the component (or file) processing order and assists the related context retrieval for the IR derivation phase. The FDG also offers a high-level aggregation perspective for the UR generation phase, allowing UserTrace to synthesize the IRs into URs. 3.3 IRs Deri… view at source ↗
Figure 5
Figure 5. Figure 5: Experimental Results for Our Case Study on the SMOS system. [PITH_FULL_IMAGE:figures/full_fig_p016_5.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. TraceDev: A Traceability-Driven Multi-agent Framework for Requirement-to-Code Development

    cs.SE 2026-07 conditional novelty 6.0

    A traceability-graph-driven multi-agent framework improves LLM-based repository-level code generation from use cases, reaching 53-57% functional success on ETOUR/SMOS versus 13-25% for ChatDev and MetaGPT.

Reference graph

Works this paper leans on

63 extracted references · 11 linked inside Pith · cited by 1 Pith paper

  1. [1]

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report.arXiv preprint arXiv:2303.08774 (2023)

    Pith/arXiv arXiv 2023

  2. [2]

    Toufique Ahmed and Premkumar Devanbu. 2022. Few-shot training llms for project-specific code-summarization. In Proceedings of the 37th IEEE/ACM international conference on automated software engineering. 1–5

    2022

  3. [3]

    Amazon. 2025. The AI IDE for prototype to production. https://kiro.dev/

    2025

  4. [4]

    Anthropic. 2025. Claude Code: Deep coding at terminal velocity. https://www.anthropic.com/claude-code

    2025

  5. [5]

    Giuliano Antoniol, Gerardo Canfora, Gerardo Casazza, Andrea De Lucia, and Ettore Merlo. 2002. Recovering traceability links between code and documentation.IEEE transactions on software engineering28, 10 (2002), 970–983

    2002

  6. [6]

    2003.Use case modeling

    Kurt Bittner and Ian Spence. 2003.Use case modeling. Addison-Wesley Professional

    2003

  7. [7]

    Jane Cleland-Huang, Raffaella Settimi, Chuan Duan, and Xuchang Zou. 2005. Utilizing supporting evidence to improve dynamic requirements traceability. In13th IEEE international conference on Requirements Engineering (RE’05). IEEE, 135–144

    2005

  8. [8]

    Jane Cleland-Huang, Michael Vierhauser, and Sean Bayley. 2018. Dronology: An incubator for cyber-physical system research.International Conference on Software Engineering (ICSE)(2018)

    2018

  9. [9]

    Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. Bert: Pre-training of deep bidirectional transformers for language understanding. InProceedings of the 2019 conference of the North American chapter of the association for computational linguistics: human language technologies, volume 1 (long and short papers). 4171–4186

    2019

  10. [10]

    Nilesh Dhulshette, Sapan Shah, and Vinay Kulkarni. 2025. Hierarchical repository-level code summarization for business applications using local llms. In2025 IEEE/ACM International Workshop on Large Language Models for Code (LLM4Code). IEEE, 145–152

    2025

  11. [11]

    Bogdan Dit, Meghan Revelle, and Denys Poshyvanyk. 2013. Integrating information retrieval, execution and link analysis algorithms to improve feature location in software.Empirical Software Engineering18, 2 (2013), 277–309

    2013

  12. [12]

    Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Wen-tau Yih, Luke Zettlemoyer, and Mike Lewis. 2022. Incoder: A generative model for code infilling and synthesis.arXiv preprint arXiv:2204.05999(2022)

    Pith/arXiv arXiv 2022

  13. [13]

    Dominik Fuchß, Tobias Hey, Jan Keim, Haoyu Liu, Niklas Ewald, Tobias Thirolf, and Anne Koziolek. 2025. LiSSA: toward generic traceability link recovery through retrieval-augmented generation. InProceedings of the IEEE/ACM 47th International Conference on Software Engineering. ICSE, Vol. 25

    2025

  14. [14]

    Hui Gao, Hongyu Kuang, Xiaoxing Ma, Hao Hu, Jian Lü, Patrick Mäder, and Alexander Egyed. 2022. Propagating frugal user feedback through closeness of code dependencies to improve IR-based traceability recovery.Empirical Software Engineering27, 2 (2022), 41

    2022

  15. [15]

    Mingyang Geng, Shangwen Wang, Dezun Dong, Haotian Wang, Ge Li, Zhi Jin, Xiaoguang Mao, and Xiangke Liao

  16. [16]

    Zi Gong, Cuiyun Gao, Yasheng Wang, Wenchao Gu, Yun Peng, and Zenglin Xu. 2022. Source code summarization with structural relative position guided transformer. In2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 13–24

    2022

  17. [17]

    John Grundy, John Hosking, and Warwick B Mugridge. 2002. Inconsistency management for multiple-view software development environments.IEEE Transactions on Software Engineering24, 11 (2002), 960–981

    2002

  18. [18]

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. 2025. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.arXiv preprint arXiv:2501.12948(2025)

    Pith/arXiv arXiv 2025

  19. [19]

    Jin Guo, Jinghui Cheng, and Jane Cleland-Huang. 2017. Semantically enhanced software traceability using deep learning techniques. In2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE). IEEE, 3–14

    2017

  20. [20]

    Sakib Haque, Alexander LeClair, Lingfei Wu, and Collin McMillan. 2020. Improved automatic summarization of subroutines via attention to file context. InProceedings of the 17th International Conference on Mining Software Repositories. 300–310

    2020

  21. [21]

    Tobias Hey, Fei Chen, Sebastian Weigelt, and Walter F Tichy. 2021. Improving traceability link recovery using fine- grained requirements-to-code relations. In2021 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 12–22

    2021

  22. [22]

    Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2018. Deep code comment generation. InProceedings of the 26th conference on program comprehension. 200–210

    2018

  23. [23]

    Xing Hu, Xin Xia, David Lo, Zhiyuan Wan, Qiuyuan Chen, and Thomas Zimmermann. 2022. Practitioners’ expectations on automated code comment generation. InProceedings of the 44th international conference on software engineering. 1693–1705

    2022

  24. [24]

    Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. 2016. Summarizing source code using a neural attention model. In54th Annual Meeting of the Association for Computational Linguistics 2016. Association for Computational Linguistics, 2073–2083

    2016

  25. [25]

    Dongming Jin, Zhi Jin, Xiaohong Chen, and Chunhui Wang. 2024. Mare: Multi-agents collaboration framework for requirements engineering.arXiv preprint arXiv:2405.03256(2024)

    Pith/arXiv arXiv 2024

  26. [26]

    Dongming Jin, Weisong Sun, Jiangping Huang, Peng Liang, Jifeng Xuan, Yang Liu, and Zhi Jin. 2025. iReDev: A Knowledge-Driven Multi-Agent Framework for Intelligent Requirements Development.arXiv preprint arXiv:2507.13081 (2025)

    Pith/arXiv arXiv 2025

  27. [27]

    Dongming Jin, Shengxin Zhao, Zhi Jin, Xiaohong Chen, Chunhui Wang, Zheng Fang, and Hongbin Xiao. 2024. An evaluation of requirements modeling for cyber-physical systems via llms.arXiv preprint arXiv:2408.02450(2024)

    Pith/arXiv arXiv 2024

  28. [28]

    Wuxia Jin, Dinghong Zhong, Yuanfang Cai, Rick Kazman, and Ting Liu. 2022. Evaluating the impact of possible dependencies on architecture-level maintainability.IEEE Transactions on Software Engineering49, 3 (2022), 1064–1085

    2022

  29. [29]

    Rodi Jolak, Simon Karlsson, and Felix Dobslaw. 2025. An empirical investigation of the impact of architectural smells on software maintainability.Journal of Systems and Software225 (2025), 112382

    2025

  30. [30]

    Hongyu Kuang, Hui Gao, Hao Hu, Xiaoxing Ma, Jian Lü, Patrick Mäder, and Alexander Egyed. 2019. Using frugal user feedback with closeness analysis on code to improve IR-based traceability recovery. In2019 IEEE/ACM 27th International Conference on Program Comprehension (ICPC). IEEE, 369–379

    2019

  31. [31]

    Hongyu Kuang, Jia Nie, Hao Hu, Patrick Rempel, Jian Lü, Alexander Egyed, and Patrick Mäder. 2017. Analyzing closeness of code dependencies for improving IR-based Traceability Recovery. In2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 68–78

    2017

  32. [32]

    Alexander LeClair, Siyuan Jiang, and Collin McMillan. 2019. A neural model for generating natural language summaries of program subroutines. In2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE, 795–806

    2019

  33. [33]

    Jia Allen Li, Yongmin Li, Ge Li, Xing Hu, Xin Xia, and Zhi Jin. 2021. Editsum: A retrieve-and-edit framework for source code summarization. In2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 155–166

    2021

  34. [34]

    Xiaoli Lian, Shuaisong Wang, Hanyu Zou, Fang Liu, Jiajun Wu, and Li Zhang. 2025. Incorporating Verification Standards for Security Requirements Generation from Functional Specifications.Proceedings of the ACM on Software Engineering2, FSE (2025), 1710–1732

    2025

  35. [35]

    LibEST. 2025. Comet Data Replication Package: LibEST. https://gitlab.com/SEMERU-Code-Public/Data/icse20-comet- data-replication-package/-/tree/main/LibEST

    2025

  36. [36]

    Chen Lin, Zhichao Ouyang, Junqing Zhuang, Jianqiang Chen, Hui Li, and Rongxin Wu. 2021. Improving code summarization with block-wise abstract syntax tree splitting. In2021 IEEE/ACM 29th International Conference on Program Comprehension (ICPC). IEEE, 184–195

    2021

  37. [37]

    Jinfeng Lin, Yalin Liu, Qingkai Zeng, Meng Jiang, and Jane Cleland-Huang. 2021. Traceability transformed: Generat- ing more accurate links with pre-trained bert models. In2021 IEEE/ACM 43rd International Conference on Software Proc. ACM Softw. Eng., Vol. 37, No. 4, Article 111. Publication date: August 2018. UserTrace: User-Level Requirements Generation a...

    2021

  38. [38]

    Yang Liu, Dan Iter, Yichong Xu, Shuohang Wang, Ruochen Xu, and Chenguang Zhu. 2023. G-eval: NLG evaluation using gpt-4 with better human alignment.arXiv preprint arXiv:2303.16634(2023)

    Pith/arXiv arXiv 2023

  39. [39]

    Andrian Marcus and Jonathan I Maletic. 2003. Recovering documentation-to-source-code traceability links using latent semantic indexing. In25th International Conference on Software Engineering, 2003. Proceedings.IEEE, 125–135

    2003

  40. [40]

    Kevin Moran, David N Palacio, Carlos Bernal-Cárdenas, Daniel McCrystal, Denys Poshyvanyk, Chris Shenefiel, and Jeff Johnson. 2020. Improving the effectiveness of traceability link recovery using hierarchical bayesian networks. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering. 873–885

    2020

  41. [41]

    Center of Excellence for Software Systems Traceability. 2025. Datasets. http://sarec.nd.edu/coest/datasets.html

    2025

  42. [42]

    1996.Requirements engineering: An overview

    Klaus Pohl. 1996.Requirements engineering: An overview. RWTH, Fachgruppe Informatik Aachen

    1996

  43. [43]

    Denys Poshyvanyk, Yann-Gaël Guéhéneuc, Andrian Marcus, Giuliano Antoniol, and Vaclav Rajlich. 2007. Feature loca- tion using probabilistic ranking of methods based on execution scenarios and information retrieval.IEEE Transactions on Software Engineering33, 6 (2007), 420–432

    2007

  44. [44]

    TechRadar Pro. 2025. The AI speed trap: why software quality Is falling behind in the race to release. https: //www.techradar.com/pro/the-ai-speed-trap-why-software-quality-is-falling-behind-in-the-race-to-release

    2025

  45. [45]

    Markus Schnappinger, Arnaud Fietzke, and Alexander Pretschner. 2020. Defining a software maintainability dataset: collecting, aggregating and analysing expert evaluations of software maintainability. In2020 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 278–289

    2020

  46. [46]

    Tjerk Spijkman, Fabiano Dalpiaz, and Sjaak Brinkkemper. 2022. Back to the roots: Linking user stories to requirements elicitation conversations. In2022 IEEE 30th International Requirements Engineering Conference (RE). IEEE, 281–287

    2022

  47. [47]

    Daniela Steidl, Benjamin Hummel, and Elmar Juergens. 2013. Quality analysis of source code comments. In2013 21st international conference on program comprehension (icpc). Ieee, 83–92

    2013

  48. [48]

    Weisong Sun, Chunrong Fang, Yudu You, Yun Miao, Yi Liu, Yuekang Li, Gelei Deng, Shenghan Huang, Yuchen Chen, Quanjun Zhang, et al. 2023. Automatic code summarization via chatgpt: How far are we?arXiv preprint arXiv:2305.12865 (2023)

    Pith/arXiv arXiv 2023

  49. [49]

    Weisong Sun, Yun Miao, Yuekang Li, Hongyu Zhang, Chunrong Fang, Yi Liu, Gelei Deng, Yang Liu, and Zhenyu Chen

  50. [50]

    Anthropic Team. 2025. Claude 3. https://claude.ai/new

    2025

  51. [51]

    Source code summarization in the era of large language models.arXiv preprint arXiv:2407.07959(2024)

    Pith/arXiv arXiv 2024

  52. [52]

    Verified Market Team. 2025. Software Maintenance Service Market Insights. https://www.verifiedmarketreports.com/ product/software-maintenance-service-market/

    2025

  53. [53]

    SlashData Team. 2025. Software development challenges are technical and Strategic. https://www.slashdata.co/post/ software-development-challenges-are-technical-and-strategic

    2025

  54. [54]

    Yao Wan, Zhou Zhao, Min Yang, Guandong Xu, Haochao Ying, Jian Wu, and Philip S Yu. 2018. Improving automatic source code summarization via deep reinforcement learning. InProceedings of the 33rd ACM/IEEE international conference on automated software engineering. 397–407

    2018

  55. [55]

    Richard Torkar, Tony Gorschek, Robert Feldt, Mikael Svahnberg, Uzair Akbar Raja, and Kashif Kamran. 2012. Require- ments traceability: a systematic review and industry case study.International Journal of Software Engineering and Knowledge Engineering22, 03 (2012), 385–433

    2012

  56. [56]

    Wenhua Wang, Yuqun Zhang, Yulei Sui, Yao Wan, Zhou Zhao, Jian Wu, Philip S Yu, and Guandong Xu. 2020. Reinforcement-learning-guided source code summarization using hierarchical attention.IEEE Transactions on software Engineering48, 1 (2020), 102–119

    2020

  57. [57]

    Huacan Wang, Ziyi Ni, Shuo Zhang, Shuo Lu, Sen Hu, Ziyang He, Chen Hu, Jiaye Lin, Yifu Guo, Ronghao Chen, et al

  58. [58]

    Dayu Yang, Antoine Simoulin, Xin Qian, Xiaoyi Liu, Yuwei Cao, Zhaopu Teng, and Grey Yang. 2025. DocAgent: A Multi-Agent System for Automated Code Documentation Generation. arXiv:2504.08725 [cs.SE]

    Pith/arXiv arXiv 2025

  59. [59]

    Stephen S Yau and James S Collofello. 2006. Some stability measures for software maintenance.IEEE Transactions on Software Engineering6 (2006), 545–552

    2006

  60. [60]

    Bolin Wei, Yongmin Li, Ge Li, Xin Xia, and Zhi Jin. 2020. Retrieve and refine: exemplar-based neural comment generation. InProceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. 349–360

    2020

  61. [63]

    Chunyan Zhang, Junchao Wang, Qinglei Zhou, Ting Xu, Ke Tang, Hairen Gui, and Fudong Liu. 2022. A survey of automatic source code summarization.Symmetry14, 3 (2022), 471. Proc. ACM Softw. Eng., Vol. 37, No. 4, Article 111. Publication date: August 2018

    2022

  62. [2024]

    Large language models are few-shot summarizers: Multi-intent comment generation via in-context learning. In Proc. ACM Softw. Eng., Vol. 37, No. 4, Article 111. Publication date: August 2018. 111:20 Dongming Jin, Zhi Jin, Yiran Zhang, Zheng Fang, Linyu Li, Yuanpeng He, Xiaohong Chen, and Weisong Sun Proceedings of the 46th IEEE/ACM International Conference...

    2018

  63. [2025]

    arXiv preprint arXiv:2505.21577(2025)

    RepoMaster: Autonomous Exploration and Understanding of GitHub Repositories for Complex Task Solving. arXiv preprint arXiv:2505.21577(2025)

    Pith/arXiv arXiv 2025

This paper was first reviewed by deepseek-v4-flash on August 4, 2026.