Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs

Alessandra Mancas; Houari Sahraoui; Hyacinth Ali; Kevin Delcourt; Mounir Ammam

REVIEW 3 major objections 4 minor 63 references

Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs

T0 review · 3 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read A ranked, iterative prompt loop lets locally deployed open-source LLMs extract domain models from Java code with F1 scores of 0.90 for classes, 0.94 for attributes, and 0.85 for associations.

desk verdict A useful local-LLM pipeline with a strong ranking ablation, but headline numbers are conditional and the aggregate tables need reconciling. read the letter →

arxiv 2608.12228 v1 pith:ENCGVJAS submitted 2026-08-12 cs.SE

Alessandra Mancas , Mounir Ammam , Hyacinth Ali , Kevin Delcourt , Houari Sahraoui This is my paper · ORCID

classification cs.SE

keywords domainmodelextractionreverseengineeringlargelanguagemodelsopen-sourceLLMsclassdiagramssemanticsimilarityrankingcontextwindowmodel-driven

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 sets out to establish that domain models—the conceptual classes, attributes, and relationships of a software system—can be recovered from source code using only compact, locally deployable open-source language models, without sending code to proprietary services. Its pipeline converts the code into an implementation-level class diagram, ranks classes by semantic similarity to a short project description, and then iteratively prompts the language model to separate domain classes from implementation details, filter attributes, and infer associations while accumulating context. On ten Java projects with expert-curated reference models, the paper reports F1 scores of 0.90 for classes, 0.94 for attributes, and 0.85 for associations, with high recall throughout. If true, this gives privacy-sensitive organizations a way to obtain higher-level models of legacy or AI-generated code on their own hardware.

What carries the argument

The load-bearing mechanism is a ranked, iterative prompt loop. Classes are ordered by cosine similarity between their names and the project documentation, computed with a sentence-embedding model, then fed one at a time to the language model with already-accepted domain classes included in each prompt, giving the model a growing local 'domain memory' without full-system context. Transitive associations reconnect domain classes that were separated when implementation classes were removed, and a final pairwise step asks the model to infer missing associations between previously unconnected domain classes. This loop is what lets a small local model approximate global reasoning under a restricted context window.

What would settle it

Run the same pipeline on a set of industrial Java projects whose existing READMEs are known to be stale or mismatched with the implemented domain, and compare class F1 against independently built reference models; if F1 stays near 0.90 despite the misaligned documentation, the ranking heuristic is not as dependent on curated input as this evaluation suggests.

Watch

Extended reading notes

Core claim

The paper's central claim is that a deliberately ordered, iterative prompting loop lets a small local model reproduce the human modeler's abstraction step: it can distinguish domain concepts from implementation scaffolding and rebuild meaningful relationships between them. The ranking stage is decisive—removing semantic-similarity ranking drops class F1 from 0.90 to 0.69, mostly through lost precision—while tokenizing class names into separate words hurts (F1 falls to 0.64), so the paper concludes that raw identifiers carry useful signal. The paper further claims the pipeline remains stable across different implementations of the same domain model, and that the recovered model can be linked back to the code artifacts it came from.

Load-bearing premise

The evaluation assumes that the short project descriptions used to rank classes are aligned with the reference domain model, because those descriptions were curated by domain experts; in real projects, READMEs that are vague or out of date would likely degrade the ranking and the classifications that depend on it.

Editorial extensions

If this is right

Privacy-sensitive organizations can extract conceptual models from legacy or AI-generated Java code entirely on their own hardware, without sending source to third-party providers.
The semantic-similarity ranking is a required component: removing it lowers class F1 from 0.90 to 0.69, so deployments should keep or strengthen the ordering step.
Tokenizing class names before classification is counterproductive; the default configuration that keeps raw identifiers is the better choice.
The same reference domain model implemented by different code bases yields comparable extraction results, suggesting the method captures domain semantics rather than surface implementation patterns.
The extracted model retains links to the underlying code, which supports traceability and downstream engineering tasks.

Reading between the lines

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

Real-world documentation is rarely curated to match a reference model, so the F1 numbers likely sit near the optimistic end; a benchmark with uncurated READMEs would quantify the drop.
A confidence threshold on each LLM classification could turn the fully automatic pipeline into an interactive one that asks humans only about uncertain elements, improving precision where it is weakest.
Because the pipeline needs only an implementation-level class diagram as input, the same design should transfer to other object-oriented languages if a counterpart to the diagram extractor exists; only Java is tested here.
The relatively low association precision (0.78) suggests spurious links are the main bottleneck, so adding evidence from method call sites or type usage may raise precision more than better prompts alone.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Main thing you should know: this is a solid, clearly written MDE paper with one real empirical insight and one reporting problem that needs fixing before publication. The new bit is not the components—SBERT ranking, iterative LLM classification, and local open-source models are all established—but the specific combination for extracting domain models from Java code, plus an ablation showing the semantic ranking is load-bearing: remove it, F1 drops from 0.90 to 0.69. That is a genuinely useful design finding, and the replication package plus three-runs averaging is more than many papers in this area ship.

The pipeline is well described. Step-by-step from code diagram to ranked classes to iterative classification to attribute filtering and association inference. RQ4 (same domain, two independent implementations) is a nice robustness check absent from related work. The authors also do not oversell the LLM itself—they are explicit that the iterative context is the main contribution. I buy the central mechanism.

Soft spots, in order of importance.

First, the headline numbers overstate end-to-end quality. Attribute and association metrics are computed only for classes already correctly identified as true positives (Section 4.2.2). That is disclosed in the metrics section, but the abstract and RQ1 answer present 0.94/0.85 as 'overall performance' without the conditional caveat. Since class precision is 0.84, a false-positive class's attributes and associations never count against the attribute/association scores, and false negatives are not penalized. End-to-end model-level F1 is lower than the table suggests. This is not a fatal flaw—conditional evaluation is common—but the central claim needs the caveat.

Second, the aggregate numbers do not match the per-case table. Macro-averaging the ten association F1 values in Table 3 gives roughly 0.77, not 0.85; similar gap for precision (0.68 vs 0.78). The discrepancy may be due to averaging across three runs at case level then macro-averaging, but the paper does not explain it. The authors need to reconcile the tables or show the aggregation method.

Third, the input documentation was curated by domain experts and matches the ground-truth vocabulary. The paper acknowledges this in Section 4.2.1 and threats to validity, and I do not think it makes the result circular—the ranking heuristic is a plausible real-world signal. But it does mean the strongest evaluation numbers likely degrade on stale or vague READMEs.

Minor: 'modest hardware' is 4x RTX 3090. That is not modest by typical industrial standards, and the paper itself later calls it high-end. Fix the wording.

Bottom line: the paper deserves a serious referee. The soft spots are report-level, not design-level, and the ranking ablation is worth preserving. I would send it to review with a request to fix the conditional metrics, reconcile the tables, and soften the claims. For someone working on LLM-based reverse engineering or MDE tooling, it's worth reading.

Referee Report

3 major / 4 minor

Summary. The paper proposes a pipeline for extracting domain models from Java source code using locally deployable open-source LLMs (LLaMA3.1-70B). The pipeline first extracts an implementation-level class diagram, ranks classes by SBERT cosine similarity between class names and project documentation, then iteratively classifies classes as domain-specific or implementation detail, filters attributes, and infers associations among the retained classes. Evaluation on ten academic Java projects with known reference domain models reports macro-averaged F1-scores of 0.90 for classes, 0.94 for attributes, and 0.85 for associations, together with ablations over tokenization and ranking. The paper answers four research questions and claims high recall with strong overall performance while remaining executable on local hardware.

Significance. The contribution is timely and practically relevant: it shows that a compact open-source model can perform a reverse-engineering task that has previously required proprietary models, and it does so with a transparent multi-stage pipeline, an ablation study isolating the contribution of semantic ranking, and a replication package. The approach is not mathematically circular: no parameters are fitted, and the pipeline is a fixed sequence of structural heuristics and LLM classifications. The main caveats are that the headline attribute and association figures are conditional on true-positive class identification, that the aggregate association numbers in Table 2 are inconsistent with the per-case values in Table 3, and that the ranking heuristic is evaluated with expert-curated documentation aligned with the ground-truth models. These issues do not invalidate the approach, but they require reframing or additional experiments before the 'strong overall performance' claim is fully supported.

major comments (3)

[§4.2.2, Tables 2–3] Table 2 reports association precision 0.78, recall 0.93, and F1 0.85, but macro-averaging the per-case association values in Table 3 gives precision 0.68 and F1 0.77. Since the per-case values in Table 3 are already averages over three runs, this is not a run-level artifact. The abstract and the RQ1 answer build on the Table 2 numbers; please report exactly how the aggregate was computed (micro vs macro, pooled over runs) and correct the discrepancy before publication.
[§4.2.2, §5.1, Abstract] Attributes and associations are evaluated only on true-positive classes, as stated in §4.2.2. This makes the reported attribute F1 of 0.94 and association F1 of 0.85 conditional on class identification rather than end-to-end model quality: a false-positive class contributes its attributes and associations to errors in a delivered model, while a false-negative class removes them from the model, and neither effect is reflected in these numbers. With class precision at 0.84 and per-case association precision as low as 0.43–0.47 for Climbsafe and AssetPlus (Table 3, cases 3, 4, 6), the difference can be material. Please report model-level metrics that include the effect of class errors, and add the 'conditional on true-positive classes' caveat to the RQ1 answer and abstract.
[§4.2.1, §7.1] The ranking heuristic in step B is validated using documentation that was curated by domain experts and is therefore aligned with the reference domain model. This is a load-bearing premise for the reported F1-scores: if real-world READMEs are outdated, vague, or use vocabulary that differs from the modeler's conceptualization, the ranking and subsequent iterative classification are likely to degrade. The threats-to-validity subsection acknowledges the risk qualitatively but does not test it. Please add an experiment with unmodified or minimally processed READMEs or requirements specifications, or explicitly narrow the applicability claim to settings where an aligned, high-level domain description is available.

minor comments (4)

[Table 3] The table header does not indicate that the association columns are computed only between true-positive classes; add a footnote so that readers do not compare association metrics directly with the end-to-end class metrics.
[§3.2, Figure 1] There are several typographical spacing errors, for example 'CoolSuppliesFxmlView scores0.4888despite' in §3.2 and 'Expert-developedCoolSuppliesdomain model' in the Figure 1 caption; please fix these before the camera-ready version.
[§5.4] The RQ4 answer that performance is 'consistent' across implementations of the same domain is based on only three pairs and no statistical or per-pair quantitative comparison; report the paired differences and, if possible, a paired test or effect-size measure.
[§3.5, §7.3] The final sentence of §3.5 states that the pipeline recovers associations without directionality or multiplicities; since a UML class diagram normally includes multiplicities, this limitation should also be stated in the RQ1 interpretation and in the abstract, not only in the future-work section.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the pipeline is an empirical, externally benchmarked approach with no fitted parameter, self-citation chain, or definitional reduction driving the reported F1 scores.

full rationale

The paper contains no derivation chain of the kind that would support a circularity finding. The pipeline takes source code and project documentation as inputs and produces a domain model; the evaluation compares that output against manually defined reference models that are independent of the pipeline's predictions. No parameter is fitted to the test data, no target quantity is defined in terms of the predicted quantity, and no uniqueness theorem or prior result from the authors is invoked to force the design choice. The reported F1 scores are computed from direct matches between extracted elements and reference models, even though the attribute and association scores are deliberately restricted to true-positive classes (Section 4.2.2), which is a disclosed metric-scoping caveat rather than a circular reduction. The curation of project descriptions by domain experts (Section 4.2.1) raises an external-validity question about whether real-world documentation would be as aligned with the ground-truth vocabulary as the curated descriptions; however, documentation is an intended input of the approach, not a quantity derived from the output, so this is a generalizability concern, not circularity. Likewise, the apparent numerical inconsistency between the macro-averaged association F1 in Table 2 and the per-case values in Table 3 is a reporting/verification issue, not a self-referential derivation. Self-citations in the paper are limited to the replication package and related prior work by co-authors; none of them supplies a load-bearing premise for the central empirical claim.

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

This is an empirical ML pipeline, not a derivation, so there are no fitted numerical parameters. The load-bearing assumptions are about the input data quality (documentation alignment and identifier semantics), the availability of a structural class diagram, and the reliability of the LLM as a classifier. The most fragile assumption is the alignment of expert-curated documentation with the ground truth, which the evaluation design itself enables.

assumptions (5)

domain assumption Java projects are object-oriented with an extractable implementation-level class diagram.
Invoked in Section 3.1, where the pipeline expects a class diagram extracted by Visual Paradigm's Instant Reverse.
domain assumption Class and attribute identifiers retain sufficient semantic information to reflect the application domain.
Stated in Section 3: 'Class and attribute identifiers should retain sufficient semantic information to reflect the application domain.' This underpins the SBERT ranking.
domain assumption A short domain-level description is available and aligned with the reference domain model.
Section 4.2.1 says the descriptions were curated by domain experts, making the input documentation close to the ground truth.
domain assumption The LLM's binary classifications (domain vs implementation, relevant vs irrelevant attribute, association vs no association) are reliable enough to serve as the pipeline's decisions.
The entire evaluation treats LLaMA3.1-70B outputs as correct; no confidence calibration or human validation is incorporated.
domain assumption SBERT cosine similarity ranks domain classes above implementation classes.
The ranking step B in Figure 3 depends on this; the ablation shows it matters, but the assumption itself is not independently validated.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs." pith.science (2026). https://pith.science/paper/ENCGVJAS

@misc{pith2026260812228,
  author       = {Pith},
  title        = {Pith review of: Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ENCGVJAS}},
  note         = {Machine review of arXiv:2608.12228}
}

read the original abstract

Large language models (LLMs) have recently shown strong capabilities for code understanding, making them promising for reverse engineering domain models from source code. However, state-ofthe- art proprietary LLMs cannot be used in many industrial contexts due to privacy and confidentiality constraints, while compact open-source LLMs that can run locally are limited by their context window and cannot process large code bases directly. In this paper, we propose an automated approach to extract domain models from source code using lightweight, locally deployable LLMs. Our method combines structural and semantic heuristics with iterative LLM-based reasoning to overcome context limitations. By progressively analyzing ranked subsets of code elements, the approach identifies domain concepts and refines domain boundaries without requiring full-system context. Our approach achieves high F1-scores on a dataset of ten projects, each comprising a curated domain model and its corresponding implementation, while remaining fully executable on locally deployable LLMs. This makes it particularly suitable for reverse engineering tasks in privacy-sensitive industrial environments.

Figures

Figures reproduced from arXiv: 2608.12228 by the authors.

**Figure 2.** Reverse engineered CoolSupplies model through our pipeline (excerpt) 3 Approach Our approach aims to extract domain models from source code using lightweight language models under limited contexts. To achieve this, we adopt a multi-stage and iterative pipeline that refines a domain model from an implementation-level representation. Illustrative example: Given the CoolSupplies project, which is a school-oriented sys… view at source ↗

**Figure 3.** Overview of the Domain Model Extraction Pipeline [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

63 extracted references · 47 canonical work pages

[1]

Imtiaz Ahmed, Sadman Islam, Partha Protim Datta, Imran Kabir, Naseef Ur Rah- man Chowdhury, and Ahshanul Haque. 2025. Qwen 2.5: A comprehensive review of the leading resource-efficient llm with potentioal to surpass all competitors. Authorea Preprints(2025)

work page 2025
[2]

Domenico Amalfitano, Andreas Metzger, Marco Autili, Tommaso Fulcini, Tobias Hey, Jan Keim, Patrizio Pelliccione, Vincenzo Scotti, Anne Koziolek, Raffaela Mirandola, et al. 2026. A Research Roadmap for Augmenting Software Engineer- ing Processes and Software Products with Generative AI.ACM Transactions on Software Engineering and Methodology(2026)

work page 2026
[3]

Shengnan An, Zexiong Ma, Zeqi Lin, Nanning Zheng, Jian-Guang Lou, and Weizhu Chen. 2024. Make your llm fully utilize the context.Advances in Neural Information Processing Systems37 (2024), 62160–62188

2024
[4]

Léna Bamouh, Thibault Béziers La Fosse, and Massimo Tisi. 2025. Towards Diagram-Based Data Model Generation with LLMs. InInternational Conference on Conceptual Modeling. Springer, 157–175

work page 2025
[5]

Meriem Ben Chaaben, Lola Burgueño, Istvan David, and Houari Sahraoui. 2025. On the Utility of Domain Modeling Assistance with Large Language Models. ACM Trans. Softw. Eng. Methodol.(June 2025). https://doi.org/10.1145/3744920

doi:10.1145/3744920 2025
[6]

Luca Berardinelli, Vittoriano Muttillo, Romina Eramo, Hugo Bruneliere, Abbas Rahimi, Antonio Cicchetti, Joan Giner-Miguelez, Abel Gomez, Pasqualina Potena, and Mehrdad Saadatmand. 2025. Model driven engineering, artificial intelligence, and devops for software and systems engineering: A systematic mapping study of synergies and challenges.ACM Transactions...

work page 2025
[7]

Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. 2021. On the opportunities and risks of foundation models.arXiv preprint arXiv:2108.07258(2021)

arXiv 2021
[8]

Artur Boronat and Jawad Mustafa. 2025. MDRE-LLM: A tool for analyzing and applying llms in software reverse engineering. In2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 850–854

work page 2025

Show all 63 references

[9]

Manfred Broy. 2013. Domain modeling and domain engineering: Key tasks in requirements engineering. InPerspectives on the Future of Software Engineering: Essays in Honor of Dieter Rombach. Springer, 15–30

2013
[10]

Hugo Bruneliere, Jordi Cabot, Grégoire Dupé, and Frédéric Madiot. 2014. Modisco: A model driven reverse engineering framework.Information and Software Tech- nology56, 8 (2014), 1012–1032

2014
[11]

Alessio Bucaioni, Antonio Cicchetti, Gordana Dodig Crnkovic, Romina Spalazzese, Emma Söderberg, and Dániel Varró. 2025. Engineering Future Critical CPSs with Trustworthy GenAI Across the Lifecycle. (2025)

2025
[12]

Victor Campanello, Shariq Shahbaz, Vladislav Indykov, and DGF Strüber. 2025. On the use of GPT-4 in the reverse engineering of class diagrams.Journal of Object Technology(2025)

2025
[13]

Thibaut Capuano, Houari Sahraouiand Benoit Frenay, and Benoit Vanderose
[14]

Kua Chen, Yujing Yang, Boqi Chen, José Antonio Hernández López, Gunter Mussbacher, and Dániel Varró. 2023. Automated domain modeling with large language models: A comparative study. In2023 ACM/IEEE 26th International Conference on Model Driven Engineering Languages and Systems...

2023
[15]

Duy Dao, Alessio Bucaioni, and Antonio Cicchetti. 2025. Learning to Transform: Evaluating LLMs on Model Transformation by Example. In2025 ACM/IEEE 28th International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C). IEEE, 576–585

2025
[16]

2004.Domain-driven design: tackling complexity in the heart of software

Eric Evans. 2004.Domain-driven design: tackling complexity in the heart of software. Addison-Wesley Professional

2004
[17]

Alessio Ferrari, Sallam Abualhaijal, and Chetan Arora. 2024. Model generation with LLMs: From requirements to UML sequence diagrams. In2024 IEEE 32nd MODELS 2026, October 04–09, 2026, Málaga, Spain Alessandra Mancas, Mounir Ammam, Hyacinth Ali, Kevin Delcourt, and Houari Sahra...

2024
[18]

Naofumi Fujishiro, Yasuhiro Otaki, and Shoji Kawachi. 2023. Accuracy of the sentence-BERT semantic search system for a Japanese database of closed medical malpractice claims.Applied Sciences13, 6 (2023), 4051

2023
[19]

Mauro Giuffrè, Simone Kresevic, Nicola Pugliese, Kisung You, and Dennis L Shung. 2024. Optimizing large language models in digestive disease: strategies and challenges to improve clinical outcomes.Liver International44, 9 (2024), 2114–2124

2024
[20]

Larissa Guder, João Paulo Aires, Hígor Uélinton da Silva, Felipe Meneguzzi, and Dalvan Griebler. 2026. Sentence representations for semantic textual similarity: A systematic review.Computer Speech & Language(2026), 101970

2026
[21]

Giancarlo Guizzardi, Guylerme Figueiredo, Maria M Hedblom, and Geert Poels
[22]

Mandy Guo, Joshua Ainslie, David C Uthus, Santiago Ontanon, Jianmo Ni, Yun- Hsuan Sung, and Yinfei Yang. 2022. LongT5: Efficient text-to-text transformer for long sequences. InFindings of the Association for Computational Linguistics: NAACL 2022. 724–736

2022
[23]

Ahmad Hatahet, Christoph Knieke, and Andreas Rausch. 2025. Generating Software Architecture Description from Source Code using Reverse Engineering and Large Language Model. In2025 ACM/IEEE 28th International Conference on Model Driven Engineering Languages and Systems Companio...

2025
[24]

Yutan Huang, Chetan Arora, Wen Cheng Huong, Tanjila Kanij, Anuradha Madugalla, and John Grundy. 2026. Ethical concerns of generative AI and miti- gation strategies: A systematic mapping study.Applied Soft Computing(2026), 114789

2026
[25]

Oseremen Joy Idialu, Noble Saji Mathews, Rungroj Maipradit, Joanne M Atlee, and Mei Nagappan. 2024. Whodunit: Classifying Code as Human Authored or GPT-4 generated-A case study on CodeChef problems. InProceedings of the 21st International Conference on Mining Software Reposito...

2024
[26]

Pragyan KC, Rocky Slavin, Sepideh Ghanavati, Travis Breaux, and Mitra Bokaei Hosseini. 2024. An Analysis of Automated Use Case Component Extraction from Scenarios using ChatGPT.arXiv preprint arXiv:2408.03395(2024)

2024 arXiv
[27]

Parham Khamsepour, Mark Cole, Ish Ashraf, DaYuan Tan, Sandeep Puri, Mehrdad Sabetzadeh, and Shiva Nejati. 2025. The Impact of Critique on LLM-Based Model Generation from Natural Language: The Case of Activity Diagrams.arXiv preprint arXiv:2509.03463(2025)

2025 arXiv
[28]

Sirojiddin Komolov, Manuel Mazzara, and Imran Sarwar Bajwa. 2026. Design Pattern Prediction From Source Code Using LLM–Based Feature Engineering and SVM Classification.IET Software2026, 1 (2026), 7163249

2026
[29]

Rainer Koschke. 2006. Architecture reconstruction: Tutorial on reverse engineer- ing to the architectural level.International Summer School on Software Engineering (2006), 140–173

2006
[30]

Minyoung Kyoung, Joon-Ho Lim, and Youngsoo Kim. 2025. Reasoning Beyond Length Limits: Improving Accuracy in Long-Context Question Answering with Small-Scale Language Models.IEEE Access(2025)

2025
[31]

Timothy C Lethbridge, Andrew Forward, Omar Badreddin, Dusan Brestovan- sky, Miguel Garzon, Hamoud Aljamaan, Sultan Eid, Ahmed Husseini Orabi, Mahmoud Husseini Orabi, Vahdat Abdelzad, et al. 2021. Umple: Model-driven development for open source and education.Science of Computer...

2021
[32]

Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019. Roberta: A robustly optimized bert pretraining approach.arXiv preprint arXiv:1907.11692 (2019)

2019 arXiv
[33]

Long Ma and Yanqing Zhang. 2015. Using Word2Vec to process big text data. In 2015 IEEE international conference on big data (Big Data). IEEE, 2895–2897

2015
[34]

2026.Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs (Replication Package)

Alessandra Mancas, Mounir Ammam, Hyacinth Ali, Kevin Delcourt, and Houari Sahraoui. 2026.Towards Automated Domain Model Extraction from Source Code using Heuristics and Open-Source LLMs (Replication Package). https://doi.org/10. 5281/zenodo.19324631

2026
[35]

Judith Michael, Loek Cleophas, Steffen Zschaler, Tony Clark, Benoit Combemale, Thomas Godfrey, Djamel Eddine Khelladi, Vinay Kulkarni, Daniel Lehner, Bern- hard Rumpe, et al. 2026. About Opportunities and Challenges in Model-Driven Engineering for Digital Twins–.Modellierung 2...

2026
[36]

Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. 2013. Efficient estimation of word representations in vector space.arXiv preprint arXiv:1301.3781 (2013)

2013 arXiv
[37]

Cameron Miskell, Richard Diaz, Parth Ganeriwala, Khaled Slhoub, and Fitzroy Nembhard. 2023. Automated framework to extract software requirements from source code. InProceedings of the 2023 7th International Conference on Natural Language Processing and Information Retrieval. 130–134

2023
[38]

Parastoo Mohagheghi and Vegard Dehlen. 2008. Where is the proof?-a review of experiences from applying mde in industry. InEuropean Conference on Model Driven Architecture-Foundations and Applications. Springer, 432–443

2008
[39]

Humza Naveed, Asad Ullah Khan, Shi Qiu, Muhammad Saqib, Saeed Anwar, Muhammad Usman, Naveed Akhtar, Nick Barnes, and Ajmal Mian. 2025. A com- prehensive overview of large language models.ACM Transactions on Intelligent Systems and Technology16, 5 (2025), 1–72

2025
[40]

Jackson Nguyen, Rui En Koe, Fanyu Wang, Chetan Arora, and Alessio Ferrari
[41]

Arka Pal, Deep Karkhanis, Manley Roberts, Samuel Dooley, Arvind Sundararajan, and Siddartha Naidu. 2023. Giraffe: Adventures in expanding context lengths in llms.arXiv preprint arXiv:2308.10882(2023)

2023 arXiv
[42]

Francisco Javier Pérez-Blanco, Juan Manuel Vara, Cristian Gómez-Macías, David Granada, and Carlos Villarrubia. 2025. Empowering Service Designers with Integrated Modelling Tools: A Model-Driven Approach.Systems13, 12 (2025), 1107

2025
[43]

Asha Rajbhoj, Akanksha Somase, Tanay Sant, Ajim Pathan, Purvesh Doud, and Vinay Kulkarni. 2025. Leveraging LLM for software modernization: COBOL Func- tionality Extraction Case study. In2025 40th IEEE/ACM International Conference on Automated Software Engineering Workshops (AS...

2025
[44]

Iris Reinhartz-Berger, Syed Juned Ali, and Dominik Bork. 2025. Leveraging LLMs for domain modeling: the impact of granularity and strategy on quality. In International conference on advanced information systems engineering. Springer, 3–19

2025
[45]

2005.The unified modeling language reference manual

James Rumbaugh. 2005.The unified modeling language reference manual. Pearson Education India

2005
[46]

Haoran Shi, Shijun Liu, and Li Pan. 2025. How LLMs Aid in Domain Modeling: Opportunities and Challenges. In2025 IEEE International Conference on Software Services Engineering (SSE). IEEE, 202–210

2025
[47]

Hanan Abdulwahab Siala and Kevin Lano. 2025. Leveraging Llms for Abstracting Uml and Ocl Representations From Java and Python Programs.A vailable at SSRN 5348203(2025)

2025
[48]

Hanan Abdulwahab Siala, Kevin Lano, and Hessa Alfraihi. 2024. Model-driven approaches for reverse engineering—a systematic literature review.IEEE Access 12 (2024), 62558–62580

2024
[49]

Margaret-Anne Storey. 2026. From Technical Debt to Cognitive and Intent Debt: Rethinking Software Health in the Age of AI.arXiv preprint arXiv:2603.22106 (2026)

2026 arXiv
[50]

Zhen Tan, Dawei Li, Song Wang, Alimohammad Beigi, Bohan Jiang, Amrita Bhattacharjee, Mansooreh Karami, Jundong Li, Lu Cheng, and Huan Liu. 2024. Large language models for data annotation and synthesis: A survey. InProceedings of the 2024 Conference on Empirical Methods in Natu...

2024
[51]

Duyu Tang, Bing Qin, and Ting Liu. 2015. Document modeling with gated recurrent neural network for sentiment classification. InProceedings of the 2015 conference on empirical methods in natural language processing. 1422–1432

2015
[52]

Andrzej Wąsowski and Thorsten Berger. 2023. Domain Analysis and Abstract Syntax. InDomain-Specific Languages: Effective Modeling, Automation, and Reuse. Springer, 47–85

2023
[53]

Song Yang and Houari Sahraoui. 2022. Towards automatically extracting UML class diagrams from natural language specifications. InProceedings of the 25th International Conference on Model Driven Engineering Languages and Systems: Companion Proceedings. 396–403

2022
[54]

Xinli Yang, David Lo, Xin Xia, and Jianling Sun. 2016. Condensing class diagrams with minimal manual labeling cost. In2016 IEEE 40th Annual Computer Software and Applications Conference (COMPSAC), Vol. 1. IEEE, 22–31

2016
[55]

Yujing Yang, Boqi Chen, Kua Chen, Gunter Mussbacher, and Dániel Varró. 2024. Multi-step iterative automated domain modeling with large language models. InProceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems. 587–595

2024
[56]

JunWeon Yoon, TaeYoung Hong, ChanYeol Park, Seo-Young Noh, and HeonChang Yu. 2020. Log analysis-based resource and execution time improvement in HPC: a case study.Applied Sciences10, 7 (2020), 2634

2020
[57]

Wenli Zhang, Weixing Zhang, Daniel Strüber, and Regina Hebig. 2025. An empirical study of manual abstraction between class diagrams and code of open- source systems.Software and Systems Modeling24, 6 (2025), 1797–1823

2025
[58]

Yizhe Zhang, Zhe Gan, Kai Fan, Zhi Chen, Ricardo Henao, Dinghan Shen, and Lawrence Carin. 2017. Adversarial feature matching for text generation. In International conference on machine learning. PMLR, 4006–4015

2017
[59]

Zeyu Zhang, Quanyu Dai, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2025. A survey on the memory mechanism of large language model-based agents.ACM Transactions on Information Systems 43, 6 (2025), 1–47

2025
[60]

Vitalii Zhelezniak, Aleksandar Savkov, April Shen, and Nils Hammerla. 2019. Correlation coefficients and semantic textual similarity. InProceedings of the 2019 conference of the north American chapter of the association for computational linguistics: Human language technologie...

2019
[2019]

In2019 13th International Conference on Research Challenges in Information Science (RCIS)

Ontology-based model abstraction. In2019 13th International Conference on Research Challenges in Information Science (RCIS). IEEE, 1–13
[2022]

Learning from Code Repositories to Recommend Model Classes.Journal of Object Technology21, 3 (2022)

2022
[2026]

Class Model Generation from Requirements using Large Language Models. (2026)

2026

Pith tools

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

[1] [1]

Imtiaz Ahmed, Sadman Islam, Partha Protim Datta, Imran Kabir, Naseef Ur Rah- man Chowdhury, and Ahshanul Haque. 2025. Qwen 2.5: A comprehensive review of the leading resource-efficient llm with potentioal to surpass all competitors. Authorea Preprints(2025)

work page 2025

[2] [2]

Domenico Amalfitano, Andreas Metzger, Marco Autili, Tommaso Fulcini, Tobias Hey, Jan Keim, Patrizio Pelliccione, Vincenzo Scotti, Anne Koziolek, Raffaela Mirandola, et al. 2026. A Research Roadmap for Augmenting Software Engineer- ing Processes and Software Products with Generative AI.ACM Transactions on Software Engineering and Methodology(2026)

work page 2026

[3] [3]

Shengnan An, Zexiong Ma, Zeqi Lin, Nanning Zheng, Jian-Guang Lou, and Weizhu Chen. 2024. Make your llm fully utilize the context.Advances in Neural Information Processing Systems37 (2024), 62160–62188

2024

[4] [4]

Léna Bamouh, Thibault Béziers La Fosse, and Massimo Tisi. 2025. Towards Diagram-Based Data Model Generation with LLMs. InInternational Conference on Conceptual Modeling. Springer, 157–175

work page 2025

[5] [5]

Meriem Ben Chaaben, Lola Burgueño, Istvan David, and Houari Sahraoui. 2025. On the Utility of Domain Modeling Assistance with Large Language Models. ACM Trans. Softw. Eng. Methodol.(June 2025). https://doi.org/10.1145/3744920

doi:10.1145/3744920 2025

[6] [6]

Luca Berardinelli, Vittoriano Muttillo, Romina Eramo, Hugo Bruneliere, Abbas Rahimi, Antonio Cicchetti, Joan Giner-Miguelez, Abel Gomez, Pasqualina Potena, and Mehrdad Saadatmand. 2025. Model driven engineering, artificial intelligence, and devops for software and systems engineering: A systematic mapping study of synergies and challenges.ACM Transactions...

work page 2025

[7] [7]

Rishi Bommasani, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, et al. 2021. On the opportunities and risks of foundation models.arXiv preprint arXiv:2108.07258(2021)

arXiv 2021

[8] [8]

Artur Boronat and Jawad Mustafa. 2025. MDRE-LLM: A tool for analyzing and applying llms in software reverse engineering. In2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 850–854

work page 2025