Pith. sign in

REVIEW 3 major objections 7 minor 4 cited by

Software Architecture Meets LLMs: A Systematic Literature Review

T0 review · 3 major / 7 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read A systematic review of 18 articles finds LLMs increasingly handling software architecture tasks and typically beating baselines, while source-code generation, cloud-native architecture, and conformance checking remain nearly unstudied.

desk verdict Useful first map of a small field, but the filtering counts don't add up and the corpus needs to be auditable before the gap claims can be trusted. read the letter →

arxiv 2505.16697 v1 pith:XUOMGUZR submitted 2025-05-22 cs.SE

Larissa Schmid , Tobias Hey , Martin Armbruster , Sophie Corallo , Dominik Fuch{ss} , Jan Keim , Haoyu Liu , Anne Koziolek This is my paper · ORCID
classification cs.SE
keywords systematicliteraturereviewsoftwarearchitecturelargelanguagemodelsLLM4SEarchitecturaltaskspromptengineeringevaluationmethodsresearchgaps
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

This systematic literature review tries to establish the current state of research at the intersection of large language models and software architecture by analyzing the 18 original studies that survived its search and filtering. It finds that these studies cluster into four task types—reference architectures, classification and detection, extraction and generation, and assistants—and that most use fully automated, end-to-end pipelines built on decoder-only models with zero-shot prompting. A sympathetic reader would take away that LLM-based approaches are doing real work in this area: where a comparison to a baseline exists, they win in six of nine cases. The review also points to tasks that are almost absent from the literature—generating source code from architectural design, cloud-native architecture, and conformance checking—as the most promising open ground.

What carries the argument

The load-bearing instrument is the review protocol itself: a five-question template covering architecture task, automation level, model choice, optimization technique, and evaluation, applied through a structured search (requiring the phrase "software architecture" plus an LLM-related term in most venues), a scope filter that excludes non-full articles, domain/UML modeling-only work, design-pattern-only work, and surveys, and a data-extraction pass on the 18 survivors. The protocol's task taxonomy—reference architectures, classification and detection, extraction and generation, assistants—is the classification scheme that turns individual papers into the review's claims about coverage and gaps.

What would settle it

Re-run the search without requiring the literal phrase "software architecture" in most venues, add snowballing of references and citations, and include general software-engineering venues; if that broader search surfaces a substantial set of studies on source-code generation from architecture, cloud-native architecture, or conformance checking—say, more than a handful—the review's gap claims would need to be revised.

Watch

Extended reading notes

Core claim

The paper's central claim is that the published corpus on LLMs and software architecture is small but coherent enough to map: 119 candidate papers reduce to 18 relevant studies. On that map, most approaches are automated (71 per cent), most use decoder-only, GPT-family models, and most rely on zero-shot prompting; evaluation is dominated by technical experiments and benchmarks, and about one-third of studies report no baseline comparison. Where baselines are present, LLM-based approaches outperform them in six studies and show mixed or negative results in three. The review treats the near absence of source-code generation from architectural design, cloud-native computing and architecture, and conformance checking not as noise but as the field's current frontiers.

Load-bearing premise

The review's map of the field rests on the assumption that its search and filtering recovered all, or a representative sample of, relevant research; if many software-architecture LLM papers were missed, the reported gaps could be artifacts of the search rather than properties of the field.

Editorial extensions

If this is right

  • The clearest open research targets are generating source code from architectural designs, cloud-native architecture, and conformance checking, each of which appears at most once in the 18-study corpus.
  • One third of surveyed studies do not compare against a baseline, so the review implies that future architecture-LLM papers should include at least one traditional or state-of-the-art baseline to make performance claims meaningful.
  • Because zero-shot prompting succeeds in most studied tasks, near-term gains in architecture work may come from task framing and prompt design rather than model fine-tuning.
  • The recent surge in publications (10 papers in 2024, five already in early 2025) suggests that LLM capability, not researcher interest, was the limiting factor for this field.

Reading between the lines

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

  • If those gaps are real, a natural next benchmark is an end-to-end pipeline that reads an architecture description, generates buildable code, and verifies conformance against architectural rules; the corpus already contains traceability-link and component-name-extraction work that such a benchmark could build on.
  • The sharp 2024-2025 increase means any static snapshot, including this review, has a short half-life; repeating the same protocol next year would likely change the model distribution and may close some reported gaps.
  • The four-category task taxonomy is a transferable coding scheme that could be applied to LLM usage in adjacent areas such as requirements engineering or technical debt, giving those communities a ready-made comparison structure.
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

3 major / 7 minor

Summary. The paper presents a systematic literature review (SLR) of the intersection of large language models (LLMs) and software architecture, following Kitchenham's guidelines. The authors report searching 25 software engineering venues, obtaining 119 initial hits, and filtering to 18 relevant articles. They analyze these articles along five research questions: which architecture tasks LLMs are applied to (RQ1) and with what automation, which LLMs are used (RQ2), which optimization and prompting techniques are applied (RQ3), how approaches are evaluated (RQ4), and what future work the primary studies suggest (RQ5). The headline findings are that LLMs are increasingly used in classification/detection, extraction/generation, assistants, and reference architectures; that most approaches use simple prompting (especially zero-shot); that LLM-based approaches often outperform baselines; and that areas such as source-code generation from architectural design, cloud-native architecture, and conformance checking remain underexplored.

Significance. If the corpus is accurately assembled, this review provides a useful early map of a rapidly growing research area and would be a valuable reference for both researchers and practitioners. The paper has clear strengths: it follows an established SLR methodology, states its research questions explicitly, reports venue and year distributions, and provides a data-availability statement with a supplementary repository. The gap claims (e.g., conformance checking, cloud-native architecture) are concrete and falsifiable, which is exactly what an SLR should offer. However, the validity of the entire descriptive synthesis rests on the auditability of the search and screening process, and that process as currently reported has unresolved arithmetic inconsistencies and a systematic search-query limitation. These issues are load-bearing rather than cosmetic, so the manuscript needs a major revision.

major comments (3)
  1. [Section 2.3] The filtering arithmetic does not reconcile with the reported 18-article corpus. Starting from 119 hits, the paper excludes 44 articles that mention 'software architecture' only in references, 12 non-full articles, 15 articles not related to software architecture and LLMs, and 1 survey, and it subsumes two articles into one (a net reduction of 1). This yields 119 - 44 - 12 - 15 - 1 - 1 = 46 articles, not 18. Roughly 28 articles that passed all listed exclusion steps disappear without explanation, and the next sentence jumps directly to 'we end up with 18 unique and relevant articles.' Because the paper's central claims about underexplored areas are absence claims, this unexplained residual makes the corpus non-auditable. Please provide a complete screening log or PRISMA-style flow diagram with per-article inclusion/exclusion decisions and reconcile the counts, either in the manuscript or by pointing to the specific supplementary table that contains the log.
  2. [Section 3.5] The RQ5 synthesis is internally inconsistent. The text states that five papers do not report future work and nine papers do, and the percentages 36% and 64% are computed over 14 papers; the figure caption, however, says n=17. Five plus nine is fourteen, not seventeen. Similarly, Section 3.4 states 'Among the fourteen studies analyzed' for the baseline comparison, without explaining why the denominator is 14 rather than 18. Please reconcile all denominators (n=14, n=17, n=18) and state clearly which studies are included in each RQ analysis; for example, if the four reference-architecture papers are excluded from certain RQs, say so explicitly.
  3. [Section 2.2] The search strategy requires the literal phrase 'software architecture' in 23 of the 25 venues; only ICSA and ECSA are exempt because their scope implies the topic. This creates a systematic blind spot for work that uses synonyms such as 'architectural conformance,' 'cloud-native design,' or 'system design' without the exact phrase. The authors acknowledge the risk of missing relevant articles in Section 4, but they do not provide a sensitivity analysis or a demonstration that the query captures such terminology. Since the paper's headline gaps (conformance checking, cloud-native architecture, code generation from architecture) are based on absence, please demonstrate that these areas are genuinely underexplored rather than merely undiscovered by the query, for example by running supplementary keyword variants or manually checking recent programs of ICSA, ECSA, ICSE, and ASE.
minor comments (7)
  1. [Section 2.2] The list of 25 venues is only available in the supplementary material; please include the full list in an appendix so the paper is self-contained.
  2. [Section 3.1] The assignment of specific articles to the four task categories would be easier to audit if presented in a table with article IDs, rather than only as prose and a summary figure.
  3. [Section 3.3] Figure 4 reports n=20 prompting techniques and n=22 evaluation methods, which exceed the 18-article corpus; please clarify in the text that one study can contribute multiple techniques or methods, and how the totals were computed.
  4. [Section 3.2] Figure 3 is difficult to read; for example, the label '61' above the GPT group is ambiguous. Consider replacing the grouping with a table of exact model counts.
  5. [Section 3.2] The text says 'Mai 2020'; this should be 'May 2020'.
  6. [Section 3.4] The categories 'technical experiment,' 'benchmarking,' and 'case study' appear to overlap; please define them clearly and explain how a study was assigned to one category when multiple evaluation methods were used.
  7. [Section 5] The statement that there are 'no articles regarding evaluating quality aspects of software architecture' and 'architecture conformance checking' should be qualified as 'none found in the selected corpus' to avoid overstating the absence, especially given the search-query limitations discussed above.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: the SLR's conclusions are corpus aggregations, not deductions; 5/18 analyzed papers are self-authored but non-load-bearing, and the §2.3 filtering arithmetic (46 ≠ 18) is an unaccounted validity risk, not a circular step.

full rationale

This paper is a systematic literature review (SLR), so its derivation chain is search -> filter -> classify -> summarize. The findings (task taxonomy of Section 3.1, model distribution of Section 3.2, optimization and evaluation summaries, and the gap claims of Section 5) are descriptive aggregations of the 18 selected studies, not results derived from equations or fitted parameters. No self-definitional reduction is present: relevance is fixed by an explicit search string and stated exclusion criteria, and the reported gaps are statements about the resulting corpus, hedged in Section 5 ('Surprisingly, we found only one work...') with the search-completeness threat acknowledged in Section 4. There is no fitted input renamed as a prediction, no imported uniqueness theorem, and no ansatz smuggled in via self-citation; the methodology follows Kitchenham et al. [18,19] and the RQ framing follows Hou et al. [11], both external. The only self-referential dependency is that 5 of the 18 analyzed primary studies ([10], [15], [16], [17], [28]) are co-authored by members of the review team, and their self-reported results (Section 3.4) are aggregated without independent validation. This is not load-bearing: the central gap claims (generating source code from architectural design, cloud-native computing and architecture, conformance checking) concern areas none of these five papers addresses, and the 'LLMs outperform baselines' synthesis is carried by external studies, with the team's own papers reported as mixed ([15]) or negative ([16]). The central claim retains independent content. Separately, the corpus is not auditable from the manuscript: Section 2.3 lists exclusions of 44 + 12 + 15 + 1 articles plus subsuming two articles into one, which yields 119 - 44 - 12 - 15 - 1 - 1 = 46, not the '18 unique and relevant articles' asserted at the start of Section 2.4; roughly 28 selections vanish without explanation. Section 3.5 likewise reports 'five papers (36%)... nine papers (64%)' whose denominator is neither 18 nor the caption's 'n=17'. These inconsistencies are reporting and validity risks for the 'underexplored' inference, not circularity, because the findings are explicitly corpus-bound summaries rather than conclusions forced by the selection rules. Score 2: minor, non-load-bearing self-citation.

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

No fitting, no new entities; contribution is a secondary synthesis.

assumptions (3)
  • domain assumption The set of 119 search results from 25 venues and Google Scholar is a complete sample of relevant LLM-software architecture research.
    The search strategy in Section 2.2 assumes the exact term 'software architecture' (or venue scope for ICSA/ECSA) captures all relevant work; the review does not validate recall quantitatively beyond a gold standard check.
  • domain assumption The inclusion/exclusion criteria (excluding UML domain models, class/activity diagrams, and design-pattern-only work) correctly operationalize the software architecture field.
    Section 2.3 applies the ICSA call-for-papers scope; this is a judgment call that shapes the corpus.
  • domain assumption The manual classification of the 18 papers into task categories, automation levels, and evaluation types is accurate.
    Section 2.4 states classifications were made by team members and discussed, but no inter-rater reliability measure is reported.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Software Architecture Meets LLMs: A Systematic Literature Review." pith.science (2026). https://pith.science/paper/XUOMGUZR

@misc{pith2026250516697,
  author       = {Pith},
  title        = {Pith review of: Software Architecture Meets LLMs: A Systematic Literature Review},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XUOMGUZR}},
  note         = {Machine review of arXiv:2505.16697}
}
read the original abstract

Large Language Models (LLMs) are used for many different software engineering tasks. In software architecture, they have been applied to tasks such as classification of design decisions, detection of design patterns, and generation of software architecture design from requirements. However, there is little overview on how well they work, what challenges exist, and what open problems remain. In this paper, we present a systematic literature review on the use of LLMs in software architecture. We analyze 18 research articles to answer five research questions, such as which software architecture tasks LLMs are used for, how much automation they provide, which models and techniques are used, and how these approaches are evaluated. Our findings show that while LLMs are increasingly applied to a variety of software architecture tasks and often outperform baselines, some areas, such as generating source code from architectural design, cloud-native computing and architecture, and checking conformance remain underexplored. Although current approaches mostly use simple prompting techniques, we identify a growing research interest in refining LLM-based approaches by integrating advanced techniques.

Figures

Figures reproduced from arXiv: 2505.16697 by the authors.

Figure 1
Figure 1. Distribution of relevant articles regarding venue and year of publication. [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Distribution of Tasks Utilizing LLMs (n=18) [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Distribution of Used Models Grouped by Their Base Approach [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Overview of used prompting techniques and used evaluation methods [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Number of occurrences for different categories of future work (n=17). [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 4 Pith papers

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

  1. Verified LLM-Driven Synthesis for Concept Design

    cs.SE 2026-07 conditional novelty 7.0 of 10

    A formal reaction semantics plus an LLM+Alloy CEGIS loop synthesizes and bounded-verifies coordination rules for Concept Design, with scenarios beating natural-language prompts for intent recovery.

  2. Large Language Models for Software Engineering Diagrams: A Systematic Review of UML and ER modelling

    cs.SE 2026-07 conditional novelty 5.0 of 10

    A systematic review of 64 papers finds LLM research on software diagrams is concentrated on UML class-diagram generation, dominated by GPT models, and held back by weak evaluation and scarce shared benchmarks.

  3. MAAD: Automate Software Architecture Design through Knowledge-Driven Multi-Agent Collaboration

    cs.SE 2025-07 conditional novelty 5.0 of 10

    A multi-agent LLM framework generates software architecture designs and evaluation reports from requirements, claimed to outperform MetaGPT on architectural completeness.

  4. Adoption of Generative Artificial Intelligence in the German Software Engineering Industry: An Empirical Study

    cs.SE 2026-01 conditional novelty 4.0 of 10

    In a survey of 109 German developers plus 18 interviews, GenAI productivity gains cluster among 'power users'; junior and senior developers perceive prompting differently, and limited codebase context is a major barrier.

Reference graph

Works this paper leans on

37 extracted references · 24 canonical work pages · cited by 4 Pith papers

  1. [1]

    Leveraging LLMs for Dynamic IoT Systems Generation through Mixed-Initiative Interaction

    Adnan, B. et al.: Leveraging LLMs for Dynamic IoT Systems Generation through Mixed-Initiative Interaction, (2025). arXiv:2502.00689 [cs.SE]. https://arxiv. org/abs/2502.00689

    work page Pith review arXiv 2025

  2. [2]

    In: Margaria, T., Steffen, B

    Ali, S., Arcaini, P., Arrieta, A.: Foundation Models for the Digital Twins Creation of Cyber-Physical Systems. In: Margaria, T., Steffen, B. (eds.) Leveraging Applications of Formal Methods, Verification and Validation. Application Areas, pp. 9–26. Springer Nature Switzerland, Cham (2025)

    work page 2025

  3. [3]

    LLMs for Generation of Architectural Components: An Exploratory Empirical Study in the Serverless World

    Arun, S., Tedla, M., Vaidhyanathan, K.: LLMs for Generation of Architectural Components: An Exploratory Empirical Study in the Serverless World. In: 22nd IEEE International Conference on Software Architecture (ICSA 2025). Institute of Electrical and Electronics Engineers (IEEE) (2025).https://arxiv.org/abs/ 2502.02539

    work page Pith review arXiv 2025

  4. [4]

    In: 2024 IEEE 21st International Conference on Software Architecture (ICSA), pp

    Dhar, R., Vaidhyanathan, K., Varma, V.: Can LLMs Generate Architectural Design Decisions? - An Exploratory Empirical Study. In: 2024 IEEE 21st International Conference on Software Architecture (ICSA), pp. 79–89 (2024).https://doi.org/ 10.1109/ICSA59870.2024.00016

    arXiv 2024

  5. [5]

    In: Software Architec- ture: 18th European Conference, ECSA 2024, Luxembourg City, Luxembourg, September 3–6, 2024, Proceedings, pp

    Díaz-Pace, J.A., Tommasel, A., Capilla, R.: Helping Novice Architects to Make Quality Design Decisions Using an LLM-Based Assistant. In: Software Architec- ture: 18th European Conference, ECSA 2024, Luxembourg City, Luxembourg, September 3–6, 2024, Proceedings, pp. 324–332. Springer-Verlag, Luxembourg City, Luxembourg (2024). https://doi.org/10.1007/978-3...

    work page doi:10.1007/978-3-031-70797-1_21 2024

  6. [6]

    Empirical Software Engineering14, 513–539 (2009)

    Dieste, O., Grimán, A., Juristo, N.: Developing search strategies for detecting relevant experiments. Empirical Software Engineering14, 513–539 (2009)

    work page 2009

  7. [8]

    In: 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE), pp

    Fan, A.et al.: Large Language Models for Software Engineering: Survey and Open Problems. In: 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE), pp. 31–53 (2023).https://doi.org/ 10.1109/ICSE-FoSE59343.2023.00008

    arXiv 2023

  8. [9]

    IEEE Transactions on Software Engineering51(2), 449–465 (2025)

    Fang, H.et al.: A Holistic Approach to Design Understanding Through Concept Explanation. IEEE Transactions on Software Engineering51(2), 449–465 (2025). https://doi.org/10.1109/TSE.2024.3522973

    work page arXiv 2025

Show all 37 references
  1. [10]

    In: 22nd IEEE International Conference on Software Architecture (ICSA 2025) (2025)

    Fuchß, D.et al.: Enabling Architecture Traceability by LLM-based Architecture Component Name Extraction. In: 22nd IEEE International Conference on Software Architecture (ICSA 2025) (2025)

    2025

  2. [11]

    et al.: Large Language Models for Software Engineering: A Systematic Literature Review

    Hou, X. et al.: Large Language Models for Software Engineering: A Systematic Literature Review. 33(8) (2024). https://doi.org/10.1145/3695988

    2024 doi

  3. [12]

    In: Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp

    Howard, J., Ruder, S.: Universal Language Model Fine-tuning for Text Classification. In: Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 328–339. Association for Computational Linguistics, Melbourne, Australi...

    2018 doi

  4. [14]

    In: Software Architecture

    Johansson, N., Caporuscio, M., Olsson, T.: Mapping Source Code to Software Architecture by Leveraging Large Language Models. In: Software Architecture. ECSA 2024 Tracks and Workshops: Luxembourg City, Luxembourg, September 3–6, 2024, Proceedings, pp. 133–149. Springer-Verlag, ...

    2024 doi

  5. [15]

    et al.: A Taxonomy for Design Decisions in Software Architecture Doc- umentation

    Keim, J. et al.: A Taxonomy for Design Decisions in Software Architecture Doc- umentation. In: Batista, T. (ed.) Software Architecture. ECSA 2022 Tracks and Workshops, pp. 439–454. Springer International Publishing, Cham (2023)

    2023

  6. [16]

    et al.: Does BERT Understand Code? – An Exploratory Study on the De- tection of Architectural Tactics in Code

    Keim, J. et al.: Does BERT Understand Code? – An Exploratory Study on the De- tection of Architectural Tactics in Code. In: Jansen, A. (ed.) Software Architecture, pp. 220–228. Springer International Publishing, Cham (2020)

    2020

  7. [17]

    et al.: Recovering Trace Links Between Software Documentation And Code

    Keim, J. et al.: Recovering Trace Links Between Software Documentation And Code. In: Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. ICSE ’24. Association for Computing Machinery, Lisbon, Portugal (2024). https://doi.org/10.1145/3597503.3639130

    2024

  8. [18]

    IEEE Transactions on Software Engineering 49(3), 1273–1298 (2023).https://doi.org/10.1109/TSE.2022.3174092

    Kitchenham, B., Madeyski, L., Budgen, D.: SEGRESS: Software Engineering Guide- lines for REporting Secondary Studies. IEEE Transactions on Software Engineering 49(3), 1273–1298 (2023).https://doi.org/10.1109/TSE.2022.3174092

    2023

  9. [19]

    Kitchenham, B.A., Charters., S.: Guidelines for performing systematic literature reviews in software engineering. Tech. rep., Technical report, ver. 2.3 ebse tech- nical report. ebse (2007). https://www .elsevier .com/__data/promis_ misc / 525444systematicreviewsguide.pdf

    2007

  10. [20]

    et al.: Evaluation Methods and Replicability of Software Architec- ture Research Objects

    Konersmann, M. et al.: Evaluation Methods and Replicability of Software Architec- ture Research Objects. In: 2022 IEEE 19th International Conference on Software Architecture (ICSA), pp. 157–168 (2022).https://doi.org/10.1109/ICSA53651. 2022.00023

    2022

  11. [21]

    1699–1704 (2023).https://doi.org/10.1109/ASE56229.2023.00206

    Le, V.-H., Zhang, H.: Log Parsing: How Far Can ChatGPT Go? In: 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), pp. 1699–1704 (2023).https://doi.org/10.1109/ASE56229.2023.00206

    2023

  12. [23]

    et al.: Architecting Digital Twins Using a Domain-Driven Design-Based Approach*

    Macías, A. et al.: Architecting Digital Twins Using a Domain-Driven Design-Based Approach*. In: 2023 IEEE 20th International Conference on Software Architecture (ICSA), pp. 153–163 (2023).https://doi.org/10.1109/ICSA56044.2023.00022

    2023

  13. [24]

    Empirical Softw

    Mahadi, A., Ernst, N.A., Tongay, K.: Conclusion stability for natural language based mining of design discussions. Empirical Softw. Engg.27(1) (2022). https: //doi.org/10.1007/s10664-021-10009-1

    2022 doi

  14. [25]

    SN Computer Science 5(4) (2024)

    Quevedo, E.et al.: Evaluating ChatGPT’s Proficiency in Understanding and Answer- ing Microservice Architecture Queries Using Source Code Insights. SN Computer Science 5(4) (2024). https://doi.org/10.1007/s42979-024-02664-0

    2024 doi

  15. [26]

    Shamsujjoha, M. et al. : Swiss Cheese Model for AI Safety: A Taxonomy and Reference Architecture for Multi-Layered Guardrails of Foundation Model Based Agents. In: 22nd IEEE International Conference on Software Architecture (ICSA 2025). Institute of Electrical and Electronics ...

    2025 arXiv

  16. [27]

    In: Galster, M

    Soliman, M.: Exploring Architectural Design Decisions in Mailing Lists and Their Traceability to Issue Trackers. In: Galster, M. (ed.) Software Architecture, pp. 307–

  17. [28]

    In: 22nd IEEE International Conference on Software Architecture (ICSA 2025)

    Soliman, M., Keim, J.: Do Large Language Models Contain Software Architectural Knowledge? An Exploratory Case Study with GPT. In: 22nd IEEE International Conference on Software Architecture (ICSA 2025). Institute of Electrical and Electronics Engineers (IEEE) (2025)

    2025

  18. [29]

    Supplementary material to the SLR,https://doi.org/10.5281/zenodo.15475475

    doi

  19. [30]

    In: Advances in Neural Information Processing Systems

    Vaswani, A.et al.: Attention Is All You Need. In: Advances in Neural Information Processing Systems. Curran Associates, Inc. (2017). (Visited on 02/25/2022)

    2017

  20. [31]

    IEEE Trans

    Wang, J.et al.: Software Testing With Large Language Models: Survey, Landscape, and Vision. IEEE Trans. Softw. Eng.50(4), 911–936 (2024).https://doi.org/10. 1109/TSE.2024.3368208

    2024

  21. [32]

    Weber, I. et al. : FhGenie: A Custom, Confidentiality-Preserving Chat AI for Corporate and Scientific Use. In: 2024 IEEE 21st International Conference on Software Architecture Companion (ICSA-C), pp. 26–31 (2024).https://doi.org/ 10.1109/ICSA-C63560.2024.00011

    2024

  22. [33]

    Springer Berlin Heidel- berg, Berlin, Heidelberg (2012)

    Wohlin, C.et al.: Experimentation in Software Engineering. Springer Berlin Heidel- berg, Berlin, Heidelberg (2012)

    2012

  23. [34]

    In: Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering

    Xiao, Y., Le, V.-H., Zhang, H.: Demonstration-Free: Towards More Practical Log Parsing with Large Language Models. In: Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. ASE ’24, pp. 153–

  24. [35]

    et al.: Large Language Models Meet NL2Code: A Survey, (2023)

    Zan, D. et al.: Large Language Models Meet NL2Code: A Survey, (2023). arXiv: 2212.09420 [cs.SE]. https://arxiv.org/abs/2212.09420

    2023 arXiv

  25. [36]

    et al.: Large Language Models for Explainable Decisions in Dynamic Digital Twins, (2024)

    Zhang, N. et al.: Large Language Models for Explainable Decisions in Dynamic Digital Twins, (2024). arXiv:2405.14411 [cs.AI]. https://arxiv.org/abs/2405. 14411

    2024 arXiv

  26. [37]

    et al.: DRMiner: Extracting Latent Design Rationale from Jira Issue Logs

    Zhao, J. et al.: DRMiner: Extracting Latent Design Rationale from Jira Issue Logs. In: Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. ASE ’24, pp. 468–480. Association for Computing Machinery, Sacramento, CA, USA (2024).https://doi...

    2024

  27. [165]

    Association for Computing Machinery, Sacramento, CA, USA (2024).https: //doi.org/10.1145/3691620.3694994

    2024

  28. [323]

    Springer Nature Switzerland, Cham (2024) Software Architecture Meets LLMs: A Systematic Literature Review 15

    2024

  29. [1031]

    (Visited on 02/23/2022)

    2022

Pith tools

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