Pith. sign in

REVIEW 4 major objections 5 minor 35 references

The importance of visual modelling languages in generative software engineering

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

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

Pith's one-line read Multimodal GPTs let developers turn UML diagrams and hand-drawn sketches directly into working Python code.

desk verdict A useful bundle of UML-to-code demonstrations, but the 'watershed' claim needs a text-only baseline before it carries weight. read the letter →

arxiv 2411.17976 v4 pith:U7XGZM2K submitted 2024-11-27 cs.SE cs.AI

Roberto Rossi This is my paper · ORCID
classification cs.SEcs.AI
keywords multimodalGPTUMLdiagramscodegenerationsoftwareengineeringgenerativeAIvisualmodellinglanguagesdiagram-basedpromptingreverse
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 aims to establish that multimodal GPTs—models that accept both images and text—are a turning point for the interaction between software engineering and generative AI. The author argues that UML diagrams and hand-drawn sketches, which developers already use for communication, can act as a high-resolution and denotative channel for guiding code generation, code summarisation, and software design. Seven use cases in the paper show a multimodal model translating class, sequence, state, and activity diagrams into working Python code, and also reverse-engineering code back into PlantUML diagrams. If the claim is right, developers gain a practical way to combine visual modelling languages with generative AI, without needing diagrams to be complete specifications—the reason earlier code-generation CASE tools struggled. The paper positions these demonstrations as the first investigation of SE tasks via multimodal GPTs prompted with a mix of diagrams and natural language.

What carries the argument

The central mechanism is the multimodal diagram-and-text prompt chain: a chat in which the user attaches an image of a UML or hand-drawn diagram together with a short text instruction, and each successive prompt builds on the previous outputs. The paper's key move is to treat visual modelling languages as denotative technical languages—they mean one thing and one thing only—in contrast to connotative natural language, and to let the diagram carry the structural information while the text carries the task instruction. PlantUML notation serves as the round-trip format: code can be produced from a diagram, and a diagram can be regenerated from code, which is what allows the author to validate the generated code and to summarise behaviour visually. The demonstrations rely on GPT-4 (via an image-capable chatbot) and an equivalent image-capable pipeline for reproducibility, with all parameters left at defaults and no role or context instructions.

What would settle it

A concrete check would be to run the same seven use-case prompts against a text-only language model given a natural-language description of each diagram (listing the classes, relations, cardinalities, and control flow) and compare the resulting code with the diagram-guided output on the same correctness criteria; if the text-only baseline matches or beats the diagram-guided version, the paper's claim that diagrams add unique value collapses. A second, cheaper check is to audit diagram-to-code outputs on a corpus of diagrams with explicit labels and cardinality constraints and count how often the generated code misses those constraints, as the paper itself reports for the reconstructed class diagram.

Watch

Extended reading notes

Core claim

The paper's central claim is that the advent of multimodal GPTs, such as GPT-4, may represent a watershed in the interplay between software engineering and generative AI, because such models accept image and text inputs and can therefore be prompted with a mix of diagrams and natural language. The core discovery, demonstrated across seven use cases, is that a multimodal GPT can use UML class diagrams, sequence diagrams, state diagrams, and hand-drawn activity diagrams to guide the implementation of Python classes, method behaviour, and complete applications, and can also generate PlantUML diagrams that summarise the structure and behaviour of code. In the author's telling, the model extracts the intended semantics from the diagrams—including relationship labels, states, and even the control flow of a hand-drawn bubble-sort activity diagram—and converts them into working code, while the reverse process produces diagrams that, in one instance, only partly capture the original cardinality constraints. The paper reports this as the first application of multimodal GPTs to software development, software design, and diagram-level code generation, and to code summarisation that returns a diagram.

Load-bearing premise

The load-bearing premise is that the multimodal model can reliably extract the intended meaning from diagram images—including connection labels, cardinality constraints, and hand-drawn notation—so the workflow is only as dependable as the model's image understanding.

Editorial extensions

If this is right

  • Developers can attach UML class, sequence, state, or activity diagrams to a multimodal GPT and get working Python code, so diagrams shift from post-hoc documentation to input specifications.
  • Code summarisation can take the form of PlantUML diagrams, giving a visual, high-resolution view of a system's structure and behaviour that complements textual summaries.
  • Design patterns can be injected visually: attaching a diagram of a pattern such as Adapter steers the model's design decisions without a lengthy textual description.
  • Complex applications (the paper shows tic tac toe and checkers) can be built incrementally through short, chained prompts that start from a class diagram and feed error stack traces back to the model.
  • Because diagrams compress information relative to natural language, diagram-based prompting is expected to be more information-efficient for SE tasks than text-only prompting.

Reading between the lines

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

  • If this workflow becomes dependable, the practical incentive to maintain live UML diagrams rises, potentially reviving modelling practices that declined after earlier code-generation tools failed.
  • The claims suggest a directly testable hypothesis: on paired diagram-versus-text descriptions of the same design, multimodal prompting should outperform text-only prompting on structural tasks such as class generation and behaviour specification.
  • The paper's own admission that cardinality constraints were not fully captured points to a natural hardening step: coupling diagram prompting with a verification pass that regenerates a diagram from the produced code and diffs it against the source diagram.
  • A further extension the author leaves implicit is treating the diagram itself as a test oracle—generating unit tests from the diagram's stated constraints and using them to validate the model's code.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper argues that multimodal GPT models such as GPT-4 mark a 'watershed' for generative software engineering because they can accept prompts that mix images of UML diagrams with natural language. The author presents a portfolio of use cases: generating Python classes from a class diagram, implementing dynamic behaviour from a sequence diagram, generating code from a hand-drawn activity diagram, applying design patterns from a class diagram, and building larger applications (an expression evaluator, tic-tac-toe, and checkers) guided by UML diagrams. The paper also demonstrates reverse engineering of PlantUML diagrams from code and reports partial successes and failures. The central claim is that diagram-based prompting is advantageous over pure natural language prompting in information-transfer efficiency, and that these use cases open new research directions in software engineering and generative AI.

Significance. If the central claim were rigorously established, the paper would open a useful direction for software engineering: visual modelling languages could become a practical interface to generative code assistants, and reverse-engineered diagrams could support code summarisation and documentation. The paper has concrete strengths: it provides documented prompt chains, includes a supplementary Gemini-based Jupyter notebook for reproducibility, and candidly reports cases where the generated output only partially matches the input diagram. However, the evidence is anecdotal, lacks a text-only baseline, and does not quantify errors or selection. The significance is therefore conditional; the paper is better read as an experience report than as a demonstration that visual structure itself is load-bearing.

major comments (4)
  1. [Abstract, Section 5] The central claim that 'diagram-based prompting may be advantageous, in terms of information transfer efficiency, compared to pure natural language prompting' is never tested against a text-only serialisation of the same diagram content. In Section 4.1 and Section 4.3, the relevant content of Figure 1 and Figure 8 (classes, attributes, operations, multiplicities, activity steps) can be fully expressed as text, yet no comparison shows whether the visual layout, cardinality notation, or spatial relationships contribute anything beyond the textual labels. Because the title and abstract rest on the visual modality adding value, this missing baseline is load-bearing.
  2. [Section 4.1, paragraph after Figure 2] The paper reports that the reconstructed class diagram 'only partly matches the original design' because cardinality constraints are not fully captured. This is an admission that image understanding is imperfect, but the work does not quantify how often or in what ways the multimodal model fails to extract intended semantics from diagram images. Without such analysis, the assumption that the workflow reliably depends on the diagram as a technical language remains unsupported.
  3. [Sections 4.3 and 4.5] The evaluation is anecdotal and lacks systematic measurement. There are no error counts, no repeated runs, no comparison conditions, and no explicit acceptance criteria. For example, Section 4.3 mentions PlantUML syntax errors in the generated activity diagram, and Section 4.5 reports ten corrective prompts for the checkers application, including game-logic errors such as a piece not being removed after a jump; these are treated as inconsequential, but they directly bear on the reliability of the proposed workflow and should be analysed rather than dismissed.
  4. [Section 3] The methodology does not specify how the presented use cases were selected or whether less successful attempts were omitted. This makes it impossible to infer the success rate of the proposed approach or to rule out selection bias. The authors should disclose the full set of attempted interactions or explicitly state the selection criteria, or alternatively frame the paper as an exploratory demonstration rather than an evaluation.
minor comments (5)
  1. [Section 4.4] The prompt text contains a typo: 'Extend the UML diagram by using the Adapter design patter' should read 'pattern'.
  2. [Sections 4.1-4.5] References to 'the SM' are vague; the supplementary material should include explicit pointers to file names, notebook cells, and line numbers for each claimed output so that readers can verify the reported interactions.
  3. [Abstract and Section 5] The claim that 'no other work has investigated similar use cases' is difficult to verify and should be scoped with a literature cut-off date or a more careful formulation, especially since the paper itself cites related work on image-based UML generation by Conrardy and Cabot.
  4. [Section 4.1] The text says the reconstructed class diagram 'only partly matches' the original but does not provide a visual diff or a list of mismatches; adding such a comparison would help readers judge the severity of the discrepancy.
  5. [Section 2.2] The description of 'Voting/self-consistency' and other prompting techniques is brief and would benefit from concrete examples tied to the use cases that follow.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper reports empirical demonstrations of multimodal GPT use cases; there are no equations, fitted parameters, or load-bearing self-citations whose conclusions are built into their inputs.

full rationale

The paper's central claims are that certain GenSE use cases with multimodal GPTs are novel and that diagram-based prompting may be efficient. The argument is carried by illustrative chat sessions in Section 4, not by a formal derivation chain. There are no fitted parameters, no equations whose outputs are defined from their inputs, no uniqueness theorems, and no ansatz secretly imported from the author's own prior work. The only substantive empirical assertion, 'diagram-based prompting may be advantageous, in terms of information transfer efficiency, compared to pure natural language prompting' (Section 5), lacks a text-only baseline and is therefore a validity/evidence weakness rather than circularity: the conclusion is not built into the demonstration, because the input diagrams are genuinely visual and the outputs (Python code, PlantUML diagrams) are independently checkable artifacts. Section 4.1 even notes that the reconstructed class diagram 'only partly matches the original design' because cardinality constraints are not fully captured, which is a candid limitation, not a circular move. Citations to [Huang et al., 2024], [Hou et al., 2024], and [Li et al., 2024b] are external support, not self-citations, and none is used to forbid alternatives or to define the paper's result into existence. No specific circular reduction can be quoted, so the honest finding is no significant circularity.

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

No free parameters or invent entities. The paper depends on empirical assumptions about LLM visual parsing and the representativeness of selected examples.

assumptions (3)
  • domain assumption Multimodal LLMs can correctly parse and interpret UML diagrams from image input.
    The entire Section 4 relies on this; e.g., Section 4.1 attaches Figure 1 and assumes Copilot derives the class structure correctly.
  • domain assumption Visual diagrams are a higher-resolution and less ambiguous communication channel than natural language for SE specifications.
    Invoked in Section 1 (Tufte quote) and Section 5 (compression argument) to support the claim of importance.
  • ad hoc to paper The reported successful examples are representative of typical use in practice.
    The conclusions about 'watershed' and future practice rest on generalizing from a handful of curated demonstrations; failures are not counted.

how reviews work

0 comments
Cite this review

Pith. "Pith review of The importance of visual modelling languages in generative software engineering." pith.science (2026). https://pith.science/paper/U7XGZM2K

@misc{pith2026241117976,
  author       = {Pith},
  title        = {Pith review of: The importance of visual modelling languages in generative software engineering},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/U7XGZM2K}},
  note         = {Machine review of arXiv:2411.17976}
}
read the original abstract

Multimodal GPTs represent a watershed in the interplay between Software Engineering and Generative Artificial Intelligence. GPT-4 accepts image and text inputs, rather than simply natural language. We investigate relevant use cases stemming from these enhanced capabilities of GPT-4. To the best of our knowledge, no other work has investigated similar use cases involving Software Engineering tasks carried out via multimodal GPTs prompted with a mix of diagrams and natural language.

Figures

Figures reproduced from arXiv: 2411.17976 by the authors.

Figure 2
Figure 2. The reconstructed class diagram 4.2 Dynamic modelling We may now want to proceed and describe the dynamic be￾haviour of the system. Rather than using natural language, we may describe specific aspect of such behaviour by leveraging suitable UML interaction diagrams, such as the sequence di￾agram in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 1
Figure 1. Class model of a library wants to obtain a preliminary code that matches this class di￾agram. Rather than using a UML diagram to code conversion tool, we will here rely on Copilot prompting with images. To achieve this, we attach [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 7
Figure 7. The revised state diagram 4.3 Hand-drawn diagrams While all the previous examples featured computer generated diagrams, Copilot is able to handle equally well hand-drawn diagrams. We consider the activity diagram shown in [PITH_FULL_IMAGE:figures/full_fig_p005_7.png] view at source ↗
Figures from the paper (5 more)
Figure 8
Figure 8. Figure 8: An activity diagram Create a method in Python that implements the at￾tached UML activity diagram. Copilot correctly recognises the fact that that the activity diagram represents a sorting algorithm (bubble sort), and re￾turns a method implementing it. Alternatively, as…
Figure 6
Figure 6. Figure 6: The desired state diagram by chaining the following prompt. Amend the Python classes to capture the behaviour in the attached state diagram. Make sure the generated code continues to reflect the original class diagram. The resulting code is presented in the SM. Finally…
Figure 11
Figure 11. Figure 11: The data transfer system Consider the class diagram in [PITH_FULL_IMAGE:figures/full_fig_p006_11.png]
Figure 9
Figure 9. Figure 9: A PlantUML activity diagram of a sorting algorithm [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]
Figure 12
Figure 12. Figure 12: The data transfer system with an adaptor. [PITH_FULL_IMAGE:figures/full_fig_p006_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

35 extracted references · 27 canonical work pages

  1. [1]

    Automatic semantic augmentation of language model prompts (for code sum- marization)

    [Ahmed et al., 2024] Toufique Ahmed, Kunal Suresh Pai, Premkumar Devanbu, and Earl Barr. Automatic semantic augmentation of language model prompts (for code sum- marization). In Proceedings of the IEEE/ACM 46th Inter- national Conference on Software Engineering , ICSE ’24, New York, NY , USA,

    work page 2024

  2. [4]

    [Baltes and Diehl, 2014] Sebastian Baltes and Stephan Diehl

    Springer Nature Switzer- land. [Baltes and Diehl, 2014] Sebastian Baltes and Stephan Diehl. Sketches and diagrams in practice. In Proceedings of the 22nd ACM SIGSOFT International Symposium on F oundations of Software Engineering, SIGSOFT/FSE’14. ACM, November

    work page 2014

  3. [8]

    On the assessment of generative ai in modeling tasks: an experience report with chatgpt and uml

    [C´amara et al., 2023] Javier C´amara, Javier Troya, Lola Bur- gue˜no, and Antonio Vallecillo. On the assessment of generative ai in modeling tasks: an experience report with chatgpt and uml. Software and Systems Modeling , 22(3):781–793, May

    work page 2023

  4. [11]

    Eapen, Daniel J

    [Eapen et al., 2023] Tojin T. Eapen, Daniel J. Finkenstadt, Josh Folk, and Lokesh Venkataswamy. How generative ai can augment human creativity. https://hbr.org/2023/07/ how-generative-ai-can-augment-human-creativity, July

    work page 2023

  5. [12]

    A survey on rag meeting llms: Towards retrieval- augmented large language models

    [Fan et al., 2024] Wenqi Fan, Yujuan Ding, Liangbo Ning, Shijie Wang, Hengyun Li, Dawei Yin, Tat-Seng Chua, and Qing Li. A survey on rag meeting llms: Towards retrieval- augmented large language models. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining , KDD ’24, page 6491–6501, New York, NY , USA,

    work page 2024

  6. [13]

    [Gamma et al., 1994] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides

    Association for Computing Machinery. [Gamma et al., 1994] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design patterns . Addison Wesley, Boston, MA, October

    work page 1994

  7. [16]

    Generative software engineer- ing

    [Huang et al., 2024] Yuan Huang, Yinan Chen, Xiangping Chen, Junqi Chen, Rui Peng, Zhicao Tang, Jinbo Huang, Furen Xu, and Zibin Zheng. Generative software engineer- ing. Technical Report arXiv:2403.02583,

    arXiv 2024

  8. [17]

    Data-driven prototyping via natural-language-based gui retrieval

    [Kolthoff et al., 2023] Kristian Kolthoff, Christian Bartelt, and Simone Paolo Ponzetto. Data-driven prototyping via natural-language-based gui retrieval. Automated Software Engineering, 30(1), March

    work page 2023

Show all 35 references
  1. [18]

    [Li et al., 2024b] Ziguang Li, Chao Huang, Xuliang Wang, Haibo Hu, Cole Wyeth, Dongbo Bu, Quan Yu, Wen Gao, Xingwu Liu, and Ming Li

    Curran Associates Inc. [Li et al., 2024b] Ziguang Li, Chao Huang, Xuliang Wang, Haibo Hu, Cole Wyeth, Dongbo Bu, Quan Yu, Wen Gao, Xingwu Liu, and Ming Li. Understanding is compression. Technical Report arXiv:2407.07723,

    arXiv

  2. [19]

    Generated knowledge prompting for commonsense reasoning

    [Liu et al., 2021] Jiacheng Liu, Alisa Liu, Ximing Lu, Sean Welleck, Peter West, Ronan Le Bras, Yejin Choi, and Han- naneh Hajishirzi. Generated knowledge prompting for commonsense reasoning. In Annual Meeting of the As- sociation for Computational Linguistics ,

    2021

  3. [21]

    [Ma et al., 2023] Qianou Ma, Tongshuang Wu, and Kenneth Koedinger

    Curran Associates Inc. [Ma et al., 2023] Qianou Ma, Tongshuang Wu, and Kenneth Koedinger. Is AI the better programming partner? Human- Human Pair Programming vs. Human-AI pAIr Program- ming. Technical Report arXiv:2306.05153,

    2023 arXiv

  4. [22]

    Large language models based automatic synthesis of soft- ware specifications

    [Mandal et al., 2023] Shantanu Mandal, Adhrik Chethan, Vahid Janfaza, S M Farabi Mahmud, Todd A Anderson, Javier Turek, Jesmin Jahan Tithi, and Abdullah Muzahid. Large language models based automatic synthesis of soft- ware specifications. Technical Report arXiv:2304.09181,

    2023 arXiv

  5. [23]

    Gpt-4 technical report

    [OpenAI, 2024] OpenAI. Gpt-4 technical report. Technical Report arXiv:2303.08774, OpenAI,

    2024 arXiv

  6. [24]

    [Robeer et al., 2016] Marcel Robeer, Garm Lucassen, Jan Martijn E. M. van der Werf, Fabiano Dalpiaz, and Sjaak Brinkkemper. Automated extraction of conceptual mod- els from user stories via nlp. In 2016 IEEE 24th Interna- tional Requirements Engineering Conference (RE) , page ...

    2016

  7. [26]

    [Stevens and Pooley, 2006] Perdita Stevens and Rob Pooley

    Curran Associates Inc. [Stevens and Pooley, 2006] Perdita Stevens and Rob Pooley. Using UML - software engineering with objects and com- ponents, Second Edition . Addison Wesley object technol- ogy series. Addison-Wesley,

    2006

  8. [30]

    How LLMs Aid in UML Mod- eling: An Exploratory Study with Novice Analysts

    [Wang et al., 2024] Beian Wang, Chong Wang, Peng Liang, Bing Li, and Cheng Zeng. How LLMs Aid in UML Mod- eling: An Exploratory Study with Novice Analysts . In 2024 IEEE International Conference on Software Services Engineering (SSE) , pages 249–257, Los Alamitos, CA, USA, July

    2024

  9. [31]

    [Wei et al., 2024] Jason Wei, Xuezhi Wang, Dale Schuur- mans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H

    IEEE Computer Society. [Wei et al., 2024] Jason Wei, Xuezhi Wang, Dale Schuur- mans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V . Le, and Denny Zhou. Chain-of-thought prompt- ing elicits reasoning in large language models. InProceed- ings of the 36th International...

    2024

  10. [32]

    [White et al., 2024] Jules White, Sam Hays, Quchen Fu, Jesse Spencer-Smith, and Douglas C

    Curran Associates Inc. [White et al., 2024] Jules White, Sam Hays, Quchen Fu, Jesse Spencer-Smith, and Douglas C. Schmidt. Chatgpt prompt patterns for improving code quality, refactoring, requirements elicitation, and software design. In Anh Nguyen-Duc, Pekka Abrahamsson, and ...

    2024

  11. [33]

    [Yao et al., 2023] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao

    Springer Nature Switzerland. [Yao et al., 2023] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language mod- els. In The Eleventh International Conference on Learning Representations,

    2023

  12. [34]

    Griffiths, Yuan Cao, and Karthik Narasimhan

    [Yao et al., 2024] Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: deliberate problem solving with large language models. In Proceedings of the 37th International Conference on Neural Information Proces...

    2024

  13. [35]

    [Zhang et al., 2024] Simiao Zhang, Jiaping Wang, Guoliang Dong, Jun Sun, Yueling Zhang, and Geguang Pu

    Curran Associates Inc. [Zhang et al., 2024] Simiao Zhang, Jiaping Wang, Guoliang Dong, Jun Sun, Yueling Zhang, and Geguang Pu. Experi- menting a new programming practice with llms. Technical Report arXiv:2401.01062, 2024

    2024 arXiv

  14. [1994]

    Gemini api docs

    [Google AI, 2025] Google AI. Gemini api docs. https://ai. google.dev/gemini-api/docs/text-generation,

    2025

  15. [2001]

    Language models are few-shot learn- ers

    [Brown et al., 2020] Tom Brown, Benjamin Mann, Nick Ry- der, Melanie Subbiah, Jared D Kaplan, Prafulla Dhari- wal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-V oss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh,...

    2020

  16. [2003]

    Attention is all you need

    [Vaswani et al., 2017] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In I. Guyon, U. V on Luxburg, S. Bengio, H. Wal- lach, R. Fergus, S. Vishwanathan, and R. Garnett, ed...

    2017

  17. [2006]

    [Tufte, 2003] E.R. Tufte. The Cognitive Style of PowerPoint. Graphics Press,

    2003

  18. [2013]

    Advancing requirements engineering through generative ai: Assessing the role of llms

    [Arora et al., 2024] Chetan Arora, John Grundy, and Mo- hamed Abdelrazek. Advancing requirements engineering through generative ai: Assessing the role of llms. In Anh Nguyen-Duc, Pekka Abrahamsson, and Foutse Khomh, editors, Generative AI for Effective Software Development, pa...

    2024

  19. [2014]

    Martin, Steve Mellor, Ken Schwaber, Jeff Sutherland, and Dave Thomas

    [Beck et al., 2001] Kent Beck, Mike Beedle, Arie van Ben- nekum, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, Jim Highsmith, Andrew Hunt, Ron Jeffries, Jon Kern, Brian Marick, Robert C. Martin, Steve Mellor, Ken Schwaber, Jeff Sutherland, and Dave Thomas....

    2001

  20. [2016]

    Reflex- ion: language agents with verbal reinforcement learning

    [Shinn et al., 2024] Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflex- ion: language agents with verbal reinforcement learning. In Proceedings of the 37th International Conference on Neural Information Processing Systems , NIPS ’23, Red...

    2024

  21. [2017]

    Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou

    [Wang et al., 2023] Xuezhi Wang, Jason Wei, Dale Schuur- mans, Quoc V Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Represen- tations,

    2023

  22. [2019]

    Clas- seval: A manually-crafted benchmark for evaluating llms on class-level code generation

    [Du et al., 2023] Xueying Du, Mingwei Liu, Kaixin Wang, Hanlin Wang, Junwei Liu, Yixuan Chen, Jiayi Feng, Chaofeng Sha, Xin Peng, and Yiling Lou. Clas- seval: A manually-crafted benchmark for evaluating llms on class-level code generation. Technical Report arXiv:2308.01861,

    2023 arXiv

  23. [2020]

    From image to uml: First results of image based uml diagram generation using llms

    [Conrardy and Cabot, 2024] Aaron Conrardy and Jordi Cabot. From image to uml: First results of image based uml diagram generation using llms. Technical Report arXiv:2404.11376,

    2024 arXiv

  24. [2021]

    Is your code generated by ChatGPT really correct? Rigorous evaluation of large lan- guage models for code generation

    [Liu et al., 2024] Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. Is your code generated by ChatGPT really correct? Rigorous evaluation of large lan- guage models for code generation. In Proceedings of the 37th International Conference on Neural Information Pr...

    2024

  25. [2023]

    BERT: pre-training of deep bidirectional transformers for language understand- ing

    [Devlin et al., 2019] Jacob Devlin, Ming-Wei Chang, Ken- ton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understand- ing. In Jill Burstein, Christy Doran, and Thamar Solorio, editors, Proceedings of the 2019 Conference of the...

    2019

  26. [2024]

    [Alur et al., 2013] Rajeev Alur, Rastislav Bodik, Garvit Ju- niwal, Milo M

    Association for Computing Machinery. [Alur et al., 2013] Rajeev Alur, Rastislav Bodik, Garvit Ju- niwal, Milo M. K. Martin, Mukund Raghothaman, San- jit A. Seshia, Rishabh Singh, Armando Solar-Lezama, Emina Torlak, and Abhishek Udupa. Syntax-guided syn- thesis. In 2013 F ormal...

    2013

  27. [2025]

    Large language models for software engineering: A systematic literature review.ACM Trans

    [Hou et al., 2024] Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. Large language models for software engineering: A systematic literature review.ACM Trans. Softw. Eng. Methodol., 33(8), December

    2024

Pith tools

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