Using large language models to generate executable BPMN models based on text descriptions: an overview of approaches, limitations, and validation methods

Operationalizing Large Language Models for Automated Software Requirement Interpretation and Change Impact Analysis

In fast-evolving software systems, effective 'natural language requirements parsing' and downstream change effect analysis capability across a multitude of codes represents low-hanging-fruit in this regard. We present a structured framework to deploy Large Language Models (LLMs) for automating two essential software engineering tasks, namely requirement interpretation and change impact analysis Utilizing the inherent understanding of semantics offered by transformer-based LLMs, the novel approach advances by converting vague and unstructured requirement documents into structured but machine-readable specifications to offer a direct traceability mapping from requirements to system components. Additionally, the framework leverages LLM-driven dependency analysis to predict and quantify how change effects percolate through connected modules which can minimize manual effort and human errors. This approach combines prompt engineering and retrieval-augmented generation (RAG) for domain-relevant accuracy plus fine-tuning techniques. On open-source and enterprise-grade software projects, experimental evaluations show that disambiguation accuracy, traceability precision, and change impact coverage of our approach are orders of magnitude better than state-of-the-art rule-based or static analysis tools. Notes: The results illustrate the application of LLMs at scale and demonstrate how these can alter software engineering workflows by removing bottlenecks (at a massive scale) at different stages of the software development lifecycle. In this research, we provide a generalizable pipeline that helps to bridge the gap from NLP advancements into practice for software lifecycle management.

Modular Meta-Languages for Structured Instructions: A Novel Approach for LLM Integration into Evolving Engineering Toolchains

Large Language Models are increasingly used to generate structured engineering artifacts, yet the instruction artifacts that govern this generation are rarely treated as modeling artifacts in their own right. They typically appear as monolithic prompt blocks, schemas, or informal examples. When tools, metamodels, APIs, or domain vocabularies evolve, stable domain concepts, volatile tool details, validators, and examples drift together in a single prompt contract. This paper puts forward the thesis that prompt-level instruction artifacts should be understood as versioned modeling languages: explicit artifacts that define the LLM-facing structure required to obtain tool-consumable outputs. We realize this idea through Modular Meta-Language-defined Structure Instructions (MMLDSI), a modular architecture that decomposes structured instructions into versioned modules with explicit interfaces, profiles, adapters, validators, examples, and deterministic rule-deck resolution. Changes to tools or domain concepts can then be represented at the affected modules and profiles rather than hidden inside whole-prompt rewrites. The approach is demonstrated in VR scene generation and automotive security modeling. Across a balanced 320-artifact VR subset, required-key validity reaches 88.1%, while a stricter prompt-contract audit accepts 80.9% and exposes remaining tool-readiness gaps. An offline monolith-to-modular pilot maps 12 legacy feature families and resolves 343 case-specific decks without dependency gaps. Our contribution is not another prompting technique, but a model-management perspective on instruction artifacts for evolving LLM toolchains.

Json-SysML: A Bidirectional JSON-Based Representation for SysML Models Enabling LLM-Augmented Model-Based Systems Engineering

Models, Prompts, and Code! A Semi-Formal State Machine Language for Multi-Paradigmatic Software Development

: Model-Driven Software Engineering has long excelled at generating code from static structural models, yet the specification and generation of dynamic behavioral models remains a persistent challenge. Meanwhile, Large Language Models (LLMs) offer flexible, natural-language based code generation but suffer from non-determinism and hallucinations. This paper presents a semi-formal approach that bridges these two paradigms for behavioral modeling via UML state machines. We contribute a textual modeling language that captures the essential elements of UML state diagrams—states, transitions, events, guards, and entry/exit actions—alongside a deterministic code generator that transforms state machine models into Java code following the Gang of Four State design pattern. The language supports two complementary action annotation styles: direct code fragments for concise, self-contained actions, and natural language descriptions for semantically richer behavior to be completed by an LLM weaver. LLM involvement is deliberately scoped to small, well-constrained action bodies, reducing token consumption and non-determinism compared to fully LLM-based approaches. Validated through the Gumball Machine case study, correctness is confirmed by automated tests covering state and transition coverage criteria, and repeating the LLM weaving step produced consistent results across all runs. Compared to both classical UML tooling and fully LLM-based generation, the approach offers stronger determinism, better traceability, lower cognitive modeling effort, and reduced computational cost, while retaining the flexibility to express complex action behavior in natural language where formal specification would be unnecessarily burdensome.

Towards LLM-Assisted Business Process Modeling in an Industrial Modeling Tool: An Experience Report

Analyzing structural and semantic similarities between formal business process models using ChatGPT-5.1: a test report

The results show that the applied LLM can reliably detect structural and semantic differences between formal business process models using Business Process Model and Notation, while distinguishing them from acceptable variations, demonstrating strong potential for automated model validation.