🤖 AI

AutoReSpec: A Framework for Generating Specification using Large Language Models

Dit paper introduceert AutoReSpec, een collaboratief framework dat dynamisch grote taalmodellen combineert en feedback gebruikt om fouten te corrigeren, waardoor het de nauwkeurigheid en efficiëntie van het genereren van formele specificaties voor Java-programma's significant verbetert ten opzichte van bestaande methoden.

Oorspronkelijke auteurs: Ragib Shahariar Ayon, Shibbir Ahmed

Gepubliceerd 2026-04-07

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Ragib Shahariar Ayon, Shibbir Ahmed

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer precieze instructiehandleiding schrijft voor een robot die een taak moet uitvoeren. Als je deze handleiding ook maar één klein foutje maakt, kan de robot de hele taak verkeerd doen of zelfs crashen. In de programmeerwereld noemen we deze handleidingen formele specificaties. Ze zijn cruciaal om te bewijzen dat software veilig en correct werkt, maar ze zijn extreem moeilijk om handmatig te schrijven. Het vereist een niveau van logica en precisie dat de meeste programmeurs niet hebben.

Recentelijk hebben we "super-intelligente" AI's (Large Language Models of LLMs) ingezet om deze handleidingen voor ons te schrijven. Maar tot nu toe was dit een beetje als een beginnende kok die een recept probeert te bedenken: soms lukt het perfect, maar vaak maakt hij fouten in de ingrediëntenlijst of de bereidingswijze, waardoor het gerecht niet eetbaar is.

AutoReSpec is een nieuw systeem dat dit probleem oplost. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De Enige Chef-Kok

Tot nu toe probeerden systemen als SpecGen of FormalBench om één AI (de "Chef-Kok") alle taken te laten doen.

Het probleem: Als de AI een fout maakt in het recept, probeert ze het gewoon opnieuw met dezelfde aanpak. Als de taak erg complex is (bijvoorbeeld een recept met veel stappen en variaties), blijft de AI vastlopen in een cirkel van fouten. Het is alsof je een beginnende kok vraagt om een 3-gangenmenu te maken terwijl hij al in paniek is; hij maakt alleen maar meer fouten.

2. De Oplossing: Een Slimme Teamleider met Twee Chefs

AutoReSpec werkt niet met één AI, maar met een slimme teamleider die twee verschillende chefs heeft:

Chef 1 (De Snelle, Goedkope Chef): Dit is een open-source AI (zoals Llama). Hij is snel en goedkoop, maar misschien niet perfect voor moeilijke taken. Hij krijgt de opdracht om het recept (de specificatie) te schrijven.
Chef 2 (De Meester-chef): Dit is een krachtige, dure AI (zoals GPT-4). Hij wordt alleen ingeroepen als Chef 1 vastloopt.

3. Hoe het Werkt: De "Check-en-Verbeter" Cyclus

Het proces ziet eruit als een slimme keuken:

De Scan: De teamleider kijkt eerst naar de code (de opdracht). Is het een simpele taak (zoals een salade maken) of een complexe taak (zoals een soufflé die in de oven moet)?
De Keuze:
- Is het simpel? Dan laat hij Chef 1 het doen.
- Is het complex? Dan kiest hij direct een combinatie van beide chefs.
De Eerste Poging: Chef 1 schrijft het recept.
De Keukencontrole (De Validator): Een robotcontroleur (OpenJML) kijkt het recept na. "Is dit veilig? Klopt de logica?"
- Als het goed is: Klaar! Het recept wordt gebruikt.
- Als er een fout is: De controleur roept: "Je hebt de suiker vergeten!" of "De temperatuur is te hoog!".
De Verbetercyclus: Chef 1 krijgt deze feedback en probeert het recept opnieuw. Hij doet dit een paar keer.
De Reddingsactie: Als Chef 1 na een paar pogingen nog steeds vastloopt (bijvoorbeeld omdat het recept te ingewikkeld is), roept de teamleider Chef 2 in.
- Chef 2 krijgt niet de hele geschiedenis van de fouten te zien (omdat dat te veel tijd kost), maar alleen het laatste mislukte recept en de specifieke foutmelding.
- Chef 2 kijkt er met een frisse blik naar, corrigeert de fout en levert een perfect recept op.

4. Waarom is dit zo slim? (De Analogie)

Stel je voor dat je een puzzel probeert op te lossen.

Oude methode: Je probeert het alleen. Als je vastloopt, blijf je proberen met dezelfde stukjes tot je moe bent.
AutoReSpec: Je hebt een vriend die meekijkt. Als jij vastloopt, zegt hij: "Hé, dat stukje past hier niet, probeer dat andere." Als jij dat ook niet lukt, belt hij een expert die binnen 5 minuten de puzzel oplost.

De Resultaten in het Kort

In hun experimenten hebben de makers AutoReSpec getest op 72 verschillende programmeertaken.

Succes: Het slaagde in 67 van de 72 gevallen. De oude methoden haalden veel minder successen.
Snelheid: Het was niet alleen accurater, maar ook nog eens 27% sneller dan de oude methoden.
Kosten: Omdat ze de dure "Meester-chef" alleen gebruiken als het echt nodig is, besparen ze veel geld en tijd.

Conclusie

AutoReSpec is als het hebben van een slimme projectmanager in plaats van één enkele werknemer. Hij weet precies wie hij moet inzetten voor welke klus, hij laat niet toe dat fouten blijven hangen, en hij zorgt ervoor dat het eindresultaat (de software-specificatie) veilig, correct en betrouwbaar is. Dit maakt het mogelijk om in de toekomst veel complexere software te bouwen zonder dat mensen urenlang handmatig naar fouten hoeven te zoeken.

Titel: AutoReSpec: Een Framework voor het Genereren van Specificaties met Grote Taalmodellen

1. Het Probleem

Formele specificaties (zoals JML voor Java) zijn essentieel voor het garanderen van programmarechtvaardigheid, automatische verificatie en testgeneratie. In de praktijk worden ze echter zelden handmatig geschreven vanwege de hoge complexiteit en de noodzaak van diepgaande expertise.
Hoewel Grote Taalmodellen (LLMs) belovend zijn voor het automatisch genereren van deze specificaties, vertonen bestaande aanpakken (zoals SpecGen en FormalBench) ernstige beperkingen:

Verificatiefouten: Genereerde specificaties falen vaak bij verificatie door syntaxisfouten, logische onnauwkeurigheden of onvolledige redenering, vooral bij programma's met loops of vertakkingslogica.
Statische prompts: Bestaande methoden gebruiken vaak statische prompts en bieden geen mechanismen om te herstellen van fouten of zich aan te passen aan verschillende programmastructuren.
Enige-model strategie: Ze vertrouwen op één model voor alle taken, wat inefficiënt is (kosten) of onvoldoende robuust (voor complexe gevallen).

2. Methodologie: Het AutoReSpec Framework

AutoReSpec is een collaboratief framework dat open-source en gesloten-source LLMs combineert om verifieerbare specificaties te genereren. Het systeem is ontworpen rond drie kernideeën:

Dynamische LLM-selectie:
- Het systeem analyseert de Abstract Syntax Tree (AST) van de invoercode om het type programma te bepalen (bijv. sequentieel, vertakkend, enkelvoudige of meervoudige loops, geneste loops).
- Op basis van dit type selecteert een "LLM Recommender" een geoptimaliseerd paar modellen: een primaire LLM (vaak een sneller, goedkoper open-source model) voor de initiële generatie en een collaboratieve LLM (een krachtiger, duurder model) als fallback bij mislukking.
Iteratieve Verificatie en Verfijning:
- De primaire LLM genereert een specificatie die direct wordt getest door een validator (OpenJML met Z3).
- Bij een verificatiefout wordt de foutmelding geanalyseerd en gebruikt om de prompt te verfijnen (conversatielus). Dit gebeurt totdat de specificatie slaagt of het iteratiebudget wordt bereikt.
Collaboratieve Herstelmechanisme:
- Als de primaire LLM faalt binnen het budget, wordt de laatste ongeldige specificatie en de bijbehorende validator-fout doorgegeven aan de collaboratieve LLM.
- Dit model voert een gerichte correctie uit zonder de volledige conversatiegeschiedenis (om context-drift en token-kosten te minimaliseren), maar met alle nodige foutinformatie.
Prompt Engineering:
- Het framework gebruikt "few-shot" voorbeelden, dynamische prompt-truncatie (om contextvensters te beheren) en foutgeleide instructies om de kwaliteit van de output te maximaliseren.

3. Belangrijkste Bijdragen

AutoReSpec Framework: Een nieuw, adaptief systeem dat LLM-paars selectie en validator-geleide conversatie combineert voor JML-specificaties.
Collaboratieve Prompt-strategie: Een methode die few-shot voorbeelden, validator-feedback en automatische prompt-truncatie combineert om lange context-interacties te ondersteunen en gerichte foutoplossing mogelijk te maken.
AutoReSpecBench: Een nieuw benchmark-dataset van 72 Java-programma's (combinatie van SpecGenBench, SV-COMP en real-world GitHub-issues) met een publieke leaderboard voor reproduceerbare evaluatie.
Open Source Tooling: De volledige release van het framework, inclusief code, dataset en een VS Code-extensie.

4. Resultaten en Evaluatie

De evaluatie is uitgevoerd op een dataset van 72 Java-programma's en vergeleken met SpecGen en FormalBench.

Succes en Dekking:
- AutoReSpec slaagde in 67 van de 72 programma's (93% succesrate), vergeleken met 58 voor SpecGen en slechts 13 voor FormalBench.
- Success Probability (SP): 58,2% voor AutoReSpec vs. 51,4% (SpecGen) en 24,3% (FormalBench).
- Completeness (C): 69,2% voor AutoReSpec, wat aangeeft dat de gegenereerde specificaties beter in staat zijn om fouten (mutaties) op te sporen.
Efficiëntie:
- De gemiddelde evaluatietijd werd met 26,89% verkort ten opzichte van eerdere methoden.
- Hoewel het iets meer validator-aanroepen doet (gemiddeld 12,4 vs. 8,2 bij SpecGen), is de totale runtime lager door slimme modelselectie en minder redundante verfijning.
- De API-kosten voor gesloten modellen zijn lager ($0,13 per klasse vs. $0,16/$ 0,17), omdat het framework prioriteit geeft aan open-source modellen en alleen dure modellen gebruikt bij noodzaak.
Foutoplossing:
- AutoReSpec toont een aanzienlijk lagere "struggle ratio" (moeite om fouten op te lossen) voor complexe fouttypes zoals Postcondition (6,55% vs. 27,06% bij SpecGen) en LoopInvariantBeforeLoop (1,16% vs. 16,67%).

5. Betekenis en Conclusie

AutoReSpec bewijst dat een collaboratieve, adaptieve aanpak superieur is aan statische, single-model strategieën voor het genereren van formele specificaties.

Schaalbaarheid: Door dynamisch te kiezen tussen goedkope en krachtige modellen, balanceert het systeem kosten en prestaties.
Robuustheid: Het mechanisme voor herstel na verificatiefouten zorgt ervoor dat zelfs complexe programma's met loops en vertakkingen succesvol kunnen worden gespecificeerd.
Toekomstperspectief: Het framework legt de basis voor verdere uitbreiding naar andere specificatietalen (zoals ACSL of Viper), het ondersteunen van multi-module systemen en het genereren van niet-functionele specificaties.

Kortom, AutoReSpec biedt een schaalbare, efficiënte en betrouwbare oplossing om de kloof tussen code en formele verificatie te dichten, wat een belangrijke stap is in de automatisering van softwarekwaliteit.