Reliability of Large Language Models for Design Synthesis: An Empirical Study of Variance, Prompt Sensitivity, and Method Scaffolding

Probleemstelling

Hoewel Large Language Models (LLMs) steeds vaker worden ingezet voor het automatiseren van software-engineeringstaken, zoals het genereren van UML-klassediagrammen uit natuurlijke taal, vertoont de huidige toepassing een fundamentele beperking. Bestaande studies tonen aan dat LLMs syntactisch correcte diagrammen kunnen produceren, maar dat syntactische validiteit niet garandeert dat het ontwerp kwalitatief goed is (bijv. onderhoudbaar, uitbreidbaar en architectonisch sound).

De kern van het probleem ligt in het onderscheid tussen diagramtranslatie en ontwerpsynthese:

• Translatie: LLMs vertalen vaak alleen oppervlakkige tekstuele entiteiten (namen, werkwoorden) naar klassen en relaties zonder de onderliggende ontwerpprincipes te begrijpen.
• Synthese: Een hoogwaardig architecturaal model vereist het impliciet afleiden van ontwerpprincipes (zoals abstractie, encapsulatie) en ontwerppatronen (zoals GoF-patronen) uit domeinvereisten, zonder dat deze expliciet in de prompt worden genoemd.

Daarnaast is er een kritiek, maar onderbelicht probleem: gedragsbetrouwbaarheid. Generatieve modellen zijn inherent niet-deterministisch. Voor architecturale workflows is stabiliteit echter essentieel; als de output sterk varieert bij kleine wijzigingen in de prompt of bij herhaalde uitvoeringen, is de praktische bruikbaarheid beperkt, ongeacht de gemiddelde prestatie.

Methodologie

De auteurs hebben een empirisch onderzoek uitgevoerd om de betrouwbaarheid en kwaliteit van LLMs bij ontwerpsynthese te evalueren.

1. Experimenteel Opzet:

• Modellen: Drie state-of-the-art modellen werden getest: ChatGPT-4o-mini, Claude 3.5 Sonnet en Gemini 2.5 Flash.
• Benchmarks: Twee domeinspecifieke scenario's met verschillende complexiteitsniveaus:
  • HMS (Hospital Management System): Medium complexiteit, focus op beleidsafhankelijk gedrag.
  • Sensor Network: Hoge complexiteit, focus op gebeurtenisgestuurde interacties.
• Aantal Experimenten: Totaal 540 runs (2 domeinen × 3 prompts per domein × 3 modellen × 3 prompting-strategieën × 10 herhalingen).
• Prompting-Strategieën:
  1. Standaard Prompting: Alleen de domeinbeschrijving zonder extra instructies.
  2. Rule-Injected Prompting: Expliciete injectie van ontwerpprincipes en regels in de prompt.
  3. Preference-based Few-shot Prompting (Voorgestelde aanpak): Een methode waarbij het model wordt blootgesteld aan contrastende voorbeelden (een "slecht" door LLM gegenereerd ontwerp vs. een "goed" door experts ontworpen ontwerp) om de output te sturen naar architectonisch sounde structuren zonder expliciete patroonnamen te noemen.

2. Evaluatiemetrics:
De evaluatie was handmatig en gebaseerd op een referentiemodel (ontworpen door een expert):

• Structuur Correctheid (M1.1): Precision, Recall en F1-score voor elementen (klassen, relaties).
• Principe-Adherentie (M1.2): Mate van naleving van OOAD-principes (abstractie, encapsulatie).
• Patroon-Emergentie (M1.3): Mate waarin ontwerppatronen (Observer, Strategy) impliciet worden toegepast.
• Stabiliteitsindex (SI): Variatie in output over herhalingen en prompt-parafrazes (hogere score = beter).

Belangrijkste Bijdragen

1. Conceptueel Kader: Het artikel schetst een duidelijk onderscheid tussen het vertalen van tekst naar diagrammen en het daadwerkelijk synthetiseren van software-ontwerpen.
2. Nieuwe Prompting-Techniek: De introductie van een preference-based few-shot prompting methode. In plaats van regels expliciet op te leggen, leert deze methode het model om "goede" versus "slechte" ontwerpen te onderscheiden via voorbeelden, wat leidt tot een betere impliciete toepassing van ontwerpprincipes.
3. Empirische Validatie van Betrouwbaarheid: Het onderzoek benadrukt dat modelkeuze een even belangrijke factor is als prompting-strategie. Het introduceert stabiliteit als een eerste-class evaluatiecriterium naast functionaliteit.

Resultaten

De resultaten tonen een complex beeld van prestaties en betrouwbaarheid:

• Invloed van Prompting:

  • De preference-based aanpak presteerde consistent beter dan standaard prompting en rule-injection. Het leidde tot een hogere adherentie aan ontwerpprincipes en een betere emergentie van patronen.
  • Rule-injection bleek niet altijd effectief; bij sommige modellen (zoals Gemini) leidde het zelfs tot een prestatiedaling door cognitieve overbelasting en hallucinaties.

• Modelverschillen (Gedragsbetrouwbaarheid):

  • Claude: Toonde een hoge decodestabiliteit. Bij dezelfde prompt leverde het zeer consistente resultaten op, hoewel de kwaliteit soms tekortschoot (bijv. het missen van abstractie).
  • ChatGPT: Toonde voorspelbaar gedrag zodra de architecturale scaffolding was vastgesteld. Fouten waren systematisch en niet stochastisch.
  • Gemini: Toonde significante variabiliteit (hoge stochastiek) over runs en prompt-parafrazes. De structuur van de diagrammen verschoof vaak, wat wijst op architecturale drift in plaats van verfijning.

• Complexiteit en Patronen:

  • Bij toenemende complexiteit (Sensor Network) daalde de prestatie van alle modellen.
  • Geen enkel model slaagde erin om het Observer-pattern correct af te leiden in een gebeurtenisgestuurde architectuur, wat aantoont dat LLMs moeite hebben met het infereren van patronen op basis van dynamisch gedrag in plaats van expliciete structurele aanwijzingen.

• Stabiliteit: De Stabiliteitsindex (SI) varieerde sterk per model, wat bevestigt dat betrouwbaarheid modelafhankelijk is.

Significantie en Conclusie

De studie concludeert dat het vertrouwen op LLMs voor software-ontwerp niet alleen een kwestie is van "klopt de output?", maar vooral "is de output betrouwbaar en reproduceerbaar?".

• Modelkeuze is cruciaal: De keuze van het LLM-model heeft een grotere invloed op de betrouwbaarheid van het ontwerp dan de gekozen prompting-strategie.
• Beperkingen van Alignment: Hoewel preference-based alignment de kans op goede ontwerpen vergroot, elimineert het de niet-deterministische aard van LLMs niet volledig.
• Toekomstperspectief: Voor betrouwbare LLM-ondersteunde software-ontwikkeling is meer nodig dan alleen prompting. Er is behoefte aan hybride benaderingen (combinatie van prompting met expliciete architecturale modules), model-finetuning en methoden om de niet-deterministische variatie te reduceren.

Kortom, LLMs kunnen fungeren als architecturale assistenten, maar hun inzet vereist een kritische evaluatie van zowel hun capaciteit om ontwerpprincipes toe te passen als hun vermogen om stabiele, reproduceerbare resultaten te leveren onder variabele omstandigheden.