💻 computer science

Contract-Coding: Towards Repo-Level Generation via Structured Symbolic Paradigm

Dit paper introduceert Contract-Coding, een gestructureerd symbolisch paradigma dat via 'Autonomous Symbolic Grounding' vage intenties omzet in formele taalcontracten om repo-level codegeneratie te verbeteren en architectonische stabiliteit te waarborgen.

Oorspronkelijke auteurs: Yi Lin, Lujin Zhao, Yijie Shi

Gepubliceerd 2026-04-16

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Yi Lin, Lujin Zhao, Yijie Shi

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

🏗️ De Bouwmeester die niet praat, maar tekent: Contract-Coding

Stel je voor dat je een gigantisch, complex gebouw wilt laten bouwen (een softwareprogramma) door een team van slimme, maar soms wat verwarde robot-bouwers (de AI).

Het oude probleem: De "Vibe" Bouw
Vroeger (en bij veel huidige AI's) gaf je de robots een vaag idee: "Bouw een kasteel dat eruitziet als een droom, met een glijbaan naar de maan." Dit noemen de auteurs "Vibe Coding".
De robots beginnen dan direct te bouwen. Eerst de toren, dan de brug, dan de muren. Maar omdat ze niet precies weten hoe de brug aan de toren moet zitten, beginnen ze te gissen.

Het resultaat: De toren is klaar, maar de brug past er niet op. De robot bouwt een nieuwe brug, maar die past weer niet op de deur.
De ramp: Naarmate het project groter wordt, raken de robots in de war. Ze vergeten wat ze eerder hebben gebouwd, maken fouten die ze niet kunnen zien, en het hele project stort in. Dit noemen ze de "Context-Fidelity Trade-off": hoe meer je wilt bouwen, hoe slechter de robots het doen omdat hun "geheugen" vol raakt met gedoe.

De nieuwe oplossing: Contract-Coding
De auteurs van dit paper zeggen: "Stop met praten en teken eerst een blauwdruk!"

Ze introduceren een nieuw systeem genaamd Contract-Coding. In plaats van dat de robots direct beginnen met stenen leggen (code schrijven), beginnen ze met het maken van een Strakke Bouwcontract.

De Vergelijking: De "Architect" en de "Bouwers"

Het Contract (De Blauwdruk):
Stel je voor dat je een architect hebt die een heel duidelijk, technisch contract maakt.
- "De deur is hier, hij is 2 meter hoog en heeft een koperen klink."
- "De trap loopt naar boven en heeft 10 treden."
  Dit contract is de enige waarheid. Het is een soort "magisch boek" dat niemand mag veranderen zonder toestemming. Het vertelt de robots precies wat ze moeten doen, zonder dat ze hoeven te raden.
De Werknemers (De AI-agenten):
In plaats van dat alle robots in één lange rij werken (eerst A, dan B, dan C), krijgen ze allemaal een kopie van dat contract.
- Robot A bouwt de deur. Hij kijkt alleen naar het contract. Hij hoeft niet te weten hoe Robot B de trap bouwt.
- Robot B bouwt de trap. Hij kijkt ook alleen naar het contract.
- Het grote voordeel: Ze kunnen allemaal tegelijk werken! Omdat ze allemaal naar hetzelfde contract kijken, weten ze precies hoe ze bij elkaar moeten passen. Ze hoeven niet te wachten op elkaar en raken niet in de war door de chaos van de ander.
De Kwaliteitscontroleur (De Auditor):
Er is een speciale robot die de hele tijd het contract bewaakt.
- Als Robot A de deur bouwt, maar hij maakt hem 2,5 meter hoog (te groot), dan zegt de Kwaliteitscontroleur: "Stop! Dat past niet in het contract. Maak het kleiner."
- Als Robot A per ongeluk de klink verandert, corrigeert de controleur dit direct.
  Dit zorgt ervoor dat fouten niet door het hele gebouw verspreiden.

Waarom is dit zo slim?

Geen "Vergeten" meer: Omdat de robots niet hoeven te onthouden wat de ander heeft gedaan (dat staat in het contract), raken ze niet in de war. Het contract is hun geheugen.
Schaalbaarheid: Je kunt nu een heel groot kasteel bouwen met 50 robots die tegelijk werken. Bij de oude methode zouden ze na 10 robots al in de war raken.
Zelfherstellend: Als er een fout ontstaat (bijvoorbeeld: de trap past niet bij de deur), herkent het systeem dit direct en laat het de robots het contract aanpassen en de fout herstellen, voordat het te laat is.

De Conclusie in één zin

Contract-Coding is als het stoppen met het geven van vaag gedoe aan een bouwteam, en in plaats daarvan een onfeilbaar, digitaal bouwplan te maken. Hierdoor kunnen honderden AI-robots tegelijkertijd aan een enorm software-project werken zonder elkaar te blokkeren of fouten te maken, omdat ze allemaal naar hetzelfde perfecte plan kijken.

Het is de overgang van "Bouw maar wat je denkt dat ik bedoel" naar "Volg dit contract, en we krijgen een perfect gebouw."

Titel: Contract-Coding: Naar Generatie op Repository-niveau via een Gestructureerd Symbolisch Paradigma

Auteurs: Yi Lin, Lujin Zhao, en Yijie Shi (Beijing University of Posts and Telecommunications)

1. Het Probleem: De Context-Fidelity Trade-off

De huidige verschuiving naar "intent-driven software engineering" (vaak "Vibe Coding" genoemd), waarbij gebruikers vage, niet-gespecificeerde doelen stellen, blootlegt een kritiek probleem in de automatische software-engineering (ASE): de Context-Fidelity Trade-off.

Huidige Beperkingen: Bestaande Multi-Agent Systemen (zoals MetaGPT en ChatDev) en "Chain-of-Thought"-benaderingen werken vaak sequentieel. Dit leidt tot twee fundamentele bottlenecks:
1. Sequentiële Entropie Accumulatie: Vroege architecturale onduidelijkheden versterken zich als semantische ruis in latere stappen.
2. Context Bottleneck: Naarmate de implementatie details zich ophopen, raakt het eindige contextvenster van LLM's verzadigd. Dit resulteert in "Architectural Collapse" (instorting van de structuur) en hallucinaties, waarbij agents niet-bestaande API's verzinnen om lokale constraints te voldoen.
Het Dilemma: Specifiek gedreven benaderingen (Spec-Coding) vereisen te gedetailleerde blauwdrukken die gebruikers zelden hebben, terwijl directe generatie vanuit vage intenties faalt door contextverlies.

2. Methodologie: Het Contract-Coding Paradigma

De auteurs stellen Contract-Coding voor, een nieuw paradigma dat vage intenties omzet in uitvoerbare code via Autonomous Symbolic Grounding. De kern van de oplossing is de Language Contract.

Kernconcepten:

Language Contract (SSOT): Een formeel, gestructureerd document dat dient als "Single Source of Truth" (SSOT). Het fungeert als een architecturale "thumbnail" die losgekoppeld is van de implementatiedetails. Het contract bevat:
- Constraint Projection: Menselijk leesbare requirements en API-specificaties.
- Executable Kernel: Een strikte logische kern (types, bestanden, staten) die de uitvoeringsgraf aanstuurt.
Symbolische Decoupling: In plaats van dat agents afhankelijk zijn van de volledige codegeschiedenis van andere agents ( $P(f_i | f_{<i})$ ), zijn ze conditioneel onafhankelijk en afhankelijk van het contract ( $P(f_i | C)$ ). Dit vermindert de informatiediepte en voorkomt contextoverbelasting.
Topologische Orkestratie (HEG): De uitvoering wordt niet lineair gestuurd, maar via een Contract-Driven Hierarchical Execution Graph (HEG).
- Agents werken parallel op basis van het contract.
- Een Contract-Guided Auditing mechanisme fungeert als een "homeostatische controller" die afwijkingen detecteert en corrigeert (bijv. door taken te herplannen of het contract dynamisch bij te werken).

Het Werkingsproces:

Symbolische Projectie: Een Generator-agent zet de vage intentie om in een eerste contract ( $C_0$ ), waarna een Discriminator-agent de architecturale geldigheid verifieert.
Topologische Orkestratie: Taken worden parallel uitgevoerd door Worker-agents die alleen het contract als context gebruiken.
Actieve Audit: Een Auditor-agent controleert continu de structuur en consistentie. Als een agent een fout maakt of het contract onvolledig is, wordt de status van de taak teruggedraaid (van DONE naar ERROR) en wordt een correctie-taak geïnitieerd.

3. Belangrijkste Bijdragen

Formalisatie van de Language Contract: Een mechanisme dat vage "vibes" autonoom omzet in een gestructureerd symbolisch paradigma, waardoor de kloof tussen Vibe Coding en Spec-Coding wordt overbrugd.
Contract-Driven Hierarchical Graph (HEG): Een nieuwe topologie die de informatiediepte verlaagt en Architectural Parallelism mogelijk maakt. Agents hoeven niet op elkaar te wachten, maar werken gelijktijdig onder de hoede van het contract.
Sub-lineaire Context Schaling: De auteurs tonen aan dat terwijl de repository-grootte lineair groeit, de grootte van het symbolische contract sub-lineair groeit. Dit comprimeert de redeneerruimte effectief en maakt het mogelijk om complexe systemen te bouwen zonder de contextlimieten van LLM's te overschrijden.

4. Resultaten (Greenfield-5 Benchmark)

De methode werd getest op de Greenfield-5 benchmark, een suite van vijf projecten variërend van logische scripts (Gomoku) tot complexe, gebeurtenisgestuurde systemen (Roguelike, City Sim).

Prestaties:
- Contract-Coding bereikte een 47% functioneel succes op de meest complexe taak (Roguelike), terwijl state-of-the-art agents (zoals OpenHands) hier op 30% zakten en academische frameworks (MetaGPT, ChatDev) vaak volledig faalden door architecturale instorting.
- Het behield near-perfecte structurele integriteit (100% op de Roguelike-taak), wat betekent dat de gegenereerde bestanden correct gekoppeld waren en geen "holle skeletten" of onbereikbare logica bevatten.
Efficiëntie:
- Token Compressie: Er werd een compressiefactor van 4.6x bereikt. Voor een project van ~8.800 tokens was het contract slechts ~1.900 tokens groot, waardoor agents niet "verloren raakten in het midden" van lange contexten.
- Snelheid: Ondanks de complexiteit van parallelle orkestratie, was het systeem aanzienlijk sneller dan zware commerciële IDE's (zoals Trae) en produceerde het schonere codebases met minder bestanden.
Vergelijking: Commerciële AI-IDEs (zoals Gemini Studio) presteerden goed door enorme contextvensters te gebruiken, maar lieten tekenen van "Probabilistic Drift" zien bij complexe taken. Contract-Coding bood een schaalbaarder alternatief zonder afhankelijk te zijn van brute-force contextvergroting.

5. Betekenis en Conclusie

Het werk markeert een kritieke stap in de richting van autonome engineering op repository-schaal.

Paradigmaverschuiving: Het beweegt de focus van strikt "specification-following" naar robuuste, intent-gedreven architectuursynthese.
Schaalbaarheid: Het bewijst dat architecturale decoupling via symbolische contracts een schaalbaarder pad is dan het simpelweg vergroten van contextvensters.
Toekomst: Door de afhankelijkheid van vage intenties te koppelen aan een auditabel, symbolisch raamwerk, maakt Contract-Coding het mogelijk om complexe softwaresystemen autonoom te bouwen met een hoge mate van betrouwbaarheid en structuur, zelfs met beperkte contextvensters.

Kortom, Contract-Coding lost het probleem van contextoverbelasting op door een "topologische hypervisor" (het contract) in te voeren die agents in staat stelt parallel te werken zonder dat ze in de valkuil van sequentiële fouten en hallucinaties terechtkomen.