💬 NLP

Learning to Commit: Generating Organic Pull Requests via Online Repository Memory

Dit paper introduceert 'Learning to Commit', een framework dat de 'organiciteit' van door LLM's gegenereerde pull requests verbetert door online repository-geheugen te gebruiken om projectspecifieke ontwikkelingspatronen te leren uit historische commits, waardoor de gegenereerde code beter aansluit bij de bestaande codebase dan bij generieke prioren.

Oorspronkelijke auteurs: Mo Li, L. H. Xu, Qitai Tan, Ting Cao, Yunxin Liu

Gepubliceerd 2026-03-30

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Mo Li, L. H. Xu, Qitai Tan, Ting Cao, Yunxin Liu

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 nieuwe medewerker aanneemt voor een heel oud, complex bedrijf. Deze nieuwe medewerker is een genie: hij kan wiskundige problemen oplossen, code schrijven en zelfs de meest ingewikkelde machines repareren. Maar er is één groot probleem: hij heeft nooit in dit specifieke bedrijf gewerkt.

Wanneer hij een taak krijgt, doet hij het misschien technisch perfect, maar het voelt "vreemd". Hij gebruikt de verkeerde gereedschappen, schrijft code die al bestaat (dus dubbel werk), en volgt de interne regels niet. De oude werknemers (de 'maintainers') zeggen dan: "Dit is technisch goed, maar het voelt alsof het door een buitenstaander is geschreven. We kunnen dit niet gebruiken."

Dit is precies het probleem dat dit paper, getiteld "Learning to Commit" (Leren om te Committen), probeert op te lossen voor AI.

Hier is de uitleg in simpele taal, met een paar leuke vergelijkingen:

1. Het Probleem: De "Buitenstaander"

Huidige AI-programmeurs zijn als die nieuwe medewerker. Ze zijn getraind op enorme hoeveelheden code van over de hele wereld (zoals een universiteit die alles leert over bouwen). Maar als ze aan een specifiek project werken, missen ze de geschiedenis.

Ze zien alleen de huidige staat van het gebouw, maar niet waarom bepaalde muren er staan, welke deuren al bestaan, of welke gewoontes de oude bewoners hebben. Ze bouwen dus vaak een nieuwe trap terwijl er al een lift is, of ze gebruiken een bouwstijl die hier nooit wordt gebruikt.

2. De Oplossing: "Online Repository Memory" (De Digitale Mentor)

De auteurs van het paper hebben een slimme methode bedacht die ze "Learning to Commit" noemen. Het idee is simpel: voordat de AI een nieuwe taak doet, moet hij eerst "leren" hoe dit specifieke bedrijf werkt.

Ze doen dit door een tijdreis te maken:

De Oude Taken: Ze nemen een lijst met oude, goedgekeurde taken uit het verleden van het bedrijf (commits).
De Blinde Poging: De AI probeert deze oude taken blind op te lossen, zonder te weten wat het juiste antwoord was.
De Vergelijking (De "Aha!"-momenten): Daarna kijken ze naar het echte antwoord (wat door een mens is gemaakt). Ze vergelijken de poging van de AI met het echte antwoord.
- Vergelijking: Stel je voor dat de AI een recept probeert te maken voor een taart. Hij doet het, maar het is te zoet. Dan kijkt hij naar het recept van de meesterkok. Hij ziet: "Ah, ik heb te veel suiker gebruikt en ik heb de boter niet op de juiste temperatuur."
Het Leerboek: De AI schrijft deze lessen op in een digitaal "Leerboek" (de Memory). Dit boek bevat niet alleen feiten, maar ook de stijl, de gebruikelijke tools en de ongeschreven regels van dit specifieke bedrijf.

3. De Toepassing: De Nieuwe Taak

Nu komt er een nieuwe, echte taak binnen. De AI pakt zijn Leerboek erbij.

In plaats van te raden, zegt hij: "Oh, in dit bedrijf gebruiken we altijd deze specifieke functie voor wachtwoorden, en we schrijven commentaar op deze manier."
Hij past zijn oplossing direct aan op basis van wat hij heeft geleerd.

Het resultaat is een stuk code dat niet alleen werkt, maar eruitziet alsof het organisch uit het project is gegroeven. Het voelt alsof het door een ervaren medewerker is geschreven die het bedrijf kent.

4. Waarom is dit zo belangrijk?

In de huidige wereld van AI-testen wordt vaak gekeken of de code "werkt" (de tests groen zijn). Maar in het echte leven kijken mensen ook naar:

Is het netjes? (Past het bij de rest?)
Is het slim? (Heeft hij de bestaande tools gebruikt of iets nieuws uitgevonden?)
Is het veilig? (Volgt het de architectuur?)

Dit paper toont aan dat als je AI eerst "leert" door naar de geschiedenis te kijken (met een strenge scheiding tussen wat hij mag leren en wat hij moet testen), hij veel betere resultaten levert. Het is alsof je een stagiair eerst een maand laat meekijken met de oude werknemers voordat je hem de sleutel geeft.

Samenvattend in één zin:

In plaats van een AI die alles weet maar niets begrijpt van een specifiek project, geven we hem een digitale mentor die hem de ongeschreven regels en de geschiedenis van het bedrijf leert, zodat hij code schrijft die echt "thuis" voelt.

Probleemstelling

Hoewel Large Language Model (LLM)-gebaseerde programmeeragenten indrukwekkende resultaten behalen op gecontroleerde benchmarks (zoals SWE-bench), falen ze vaak in de praktijk bij het genereren van "organische" pull requests (PR's) die door echte maintainers worden geaccepteerd.

De Kern: Het probleem is niet dat de gegenereerde code functioneel onjuist is, maar dat het ontbreekt aan organiciteit. De code negeert projectspecifieke conventies, dupliceert functionaliteit die al bestaat via interne API's, en schendt impliciete architecturale beperkingen die over jaren zijn opgebouwd.
Huidige Tekortkomingen: Bestaande benchmarks behandelen software-engineering als een reeks geïsoleerde taken zonder rekening te houden met de chronologische evolutie van een repository. Agenten krijgen geen "onboarding" en missen dus de context van waarom bepaalde keuzes in het verleden zijn gemaakt. Dit leidt tot "vreemde" code: syntactisch correct, maar architecturaal dissonant en vaak overbodig uitgebreid.
Datalekken: Veel evaluaties lijden onder datalekken (pre-training data), waardoor agenten al eerder hebben gezien wat ze moeten doen. Er is behoefte aan een evaluatie die strikt chronologisch is opgedeeld.

Methodologie: Learning to Commit

Het paper introduceert Learning to Commit, een raamwerk dat de kloof dicht door Online Repository Memory te gebruiken. Het doel is dat de agent leert van de geschiedenis van de repository voordat hij nieuwe taken uitvoert.

Het proces verloopt in twee fasen, gescheiden door een strikte tijdsplitsing ( $T^*$ ):

Fase 1: Repository Onboarding via Contrastieve Reflectie (Leerfase)
- De agent krijgt toegang tot historische commits ( $C^-$ ) vóór de tijdsplitsing.
- Blind Attempt: Voor elke historische commit probeert de agent blindelings het probleem op te lossen op basis van een synthetische issue-beschrijving, zonder de oplossing te kennen.
- Oracle Diff & Reflectie: De echte oplossing (de "oracle diff" van de menselijke expert) wordt onthuld. De agent vergelijkt zijn eigen poging met de echte oplossing.
- Supervised Contrastive Distillation: Het verschil tussen de poging en de echte oplossing dient als een leer signaal. De agent distilleert deze verschillen naar een gestructureerd vaardigheidsdocument (Skill Document, $M$ ).
- Dit document bevat abstracte, herbruikbare patronen: code-stijl, intern API-gebruik, architecturale grenzen en maintainer-preferenties.
Fase 2: Vaardigheids-geconditioneerde Oplossing (Testfase)
- Voor nieuwe, toekomstige taken ( $C^+$ ) die na de tijdsplitsing liggen, gebruikt de agent het opgebouwde vaardigheidsdocument $M$ .
- De agent lost de taak op door zijn generatie te conditioneren op deze opgeslagen kennis, waardoor de output beter aansluit bij de evolutie en conventies van de repository.

Dataset Constructie:
De auteurs gebruiken een interne, door experts onderhouden repository. Ze filteren commits op kwaliteit, clusteren ze in categorieën (bijv. architectuur, concurrentie) en splitsen ze strikt chronologisch om datalekken te voorkomen. Synthetische issues worden gegenereerd die de implementatiedetails verbergen.

Belangrijkste Bijdragen

Formalisatie van Repository-Personalisatie: Het paper introduceert een raamwerk voor online adaptatie waarbij agenten organisch kunnen aligneren met evoluerende codebases via een leermechanisme.
Training-vrije, Online Vaardigheidsextractie: Een methode om repository-specifieke conventies te distilleren via supervised contrastive reflection. De agent leert door zijn eigen fouten te vergelijken met expert-oplossingen, wat leidt tot een continu groeiende set vaardigheden.
Strict Tijdsplit Benchmark: Een nieuwe evaluatieopzet met multi-dimensionale metrics (code-stijl, API-hergebruik, plausibiliteit van gewijzigde regio's) die datalekken volledig uitsluit.

Resultaten

De experimenten werden uitgevoerd op een interne repository met 24 leer-communicaties en 7 toekomstige test-taken. De resultaten tonen aan dat de agent met vaardigheidsmemory ( $M$ ) significant beter presteert dan een baseline-agent zonder memory:

Localisatie (File IoU): De vaardigheids-agent verbeterde de nauwkeurigheid van het vinden van de juiste bestanden met tot +19% (80% vs 61% in de seq-all setting).
Efficiëntie: De agent maakte 21% minder tool-aanroepen (stappen) om de taak op te lossen, wat aangeeft dat hij de codebase efficiënter navigeert.
Patch Bloat: De "Line Deviation Ratio" (hoeveelheid extra code) was lager, wat betekent dat de patches compacter waren en minder interne API's opnieuw implementeerden.
LLM-judges: Onafhankelijke LLM-judges (Claude en Gemini) gaven de vaardigheids-agent vaker de voorkeur, vooral op de dimensies Logische Similariteit (50% vs 25%) en Redundantie-reductie (54% vs 41%).
Nuance: De grootste verbetering zat in het begrijpen van waar wijzigingen nodig zijn en welke interne patronen te hergebruiken. Fijne code-stijl en scope-alignment lieten minder duidelijke verbeteringen zien, wat suggereert dat deze aspecten mogelijk extra mechanismen vereisen.

Betekenis en Toekomst

Dit werk markeert een verschuiving in de evaluatie van programmeeragenten: van het oplossen van geïsoleerde taken naar het beheer van geheugen over sessies en tijd.

Het bewijst dat "onboarding" (het leren van de geschiedenis van een project) essentieel is voor het genereren van code die door menselijke maintainers als natuurlijk wordt ervaren.
Het raamwerk biedt een solide basis voor toekomstig onderzoek naar het schalen van dit proces naar diverse open-source GitHub-repositories en het ontwikkelen van robuustere, niet-LLM-gebaseerde evaluatiemetrics voor menselijke coderingsvoorkeuren.

Kortom, Learning to Commit transformeert de agent van een statische code-generator naar een dynamische leerling die de cultuur en architectuur van een project internaliseert, wat essentieel is voor succesvolle industriële implementatie.