CodeMidas: AI-agents leren coderen van bestaande software

TL;DR

• Wat: Onderzoekers hebben met CodeMidas een methode ontwikkeld om automatisch trainingstaken te genereren uit bestaande broncode — 5.545 taken uit 3.185 open-source projecten.
• Waarom relevant: AI-agents die zelfstandig software kunnen schrijven en repareren worden hierdoor sneller beter, wat de beschikbaarheid en betaalbaarheid van codeertools beïnvloedt.
• Wat je ermee kunt: Houd in de gaten hoe snel AI-codeertools verbeteren — de drempel om software te laten bouwen of aanpassen door AI daalt meetbaar.

Ik stuitte op een nieuw onderzoekspaper dat me opviel vanwege de aanpak: in plaats van AI te trainen op door mensen geschreven instructies, halen de onderzoekers trainingstaken direct uit bestaande software. Het paper heet CodeMidas en beschrijft hoe je broncode zelf kunt omzetten in oefenmateriaal voor AI-agents. Dat vind ik een interessant idee om uit te pluizen.

Wat is CodeMidas precies?

CodeMidas is een zogenaamde agentic pipeline — een geautomatiseerd proces waarbij AI-agents zelf het werk doen. Het idee is als volgt: neem een bestaande codebase (een softwareproject), en laat AI-agents die code verkennen om er trainingstaken van te maken.

Dat klinkt misschien abstract, dus laat me het vergelijken met iets bekenders. Stel je voor dat je een nieuwe kok wilt opleiden, maar in plaats van een kookboek te schrijven, zet je diegene in een werkende keuken en zeg je: "Kijk wat hier gemaakt wordt, begrijp het recept, en bewijs dat je het zelf kunt." Dat is in essentie wat CodeMidas doet met software.

Concreet doorloopt het systeem drie stappen:

1. Verkennen: AI-agents onderzoeken wat de code doet en formuleren gedragsspecificaties — een soort beschrijving van het gewenste resultaat.
2. Testen bouwen: Op basis van de werkende code worden automatisch tests gegenereerd die controleren of een oplossing klopt.
3. Valideren: De taken worden gefilterd door ze daadwerkelijk uit te voeren en herhaaldelijk te laten oplossen, zodat alleen betrouwbare taken overblijven.

Het bijzondere is dat dit alles gebeurt zonder menselijke tussenkomst en zonder afhankelijkheid van zaken als issue-trackers of commit-geschiedenissen. De broncode zelf is het enige ingrediënt.

De cijfers: 5.545 taken uit 3.185 projecten

De onderzoekers hebben CodeMidas losgelaten op 3.185 open-source codebases. Dat leverde 5.545 bruikbare trainingstaken op, verspreid over 23 programmeertalen en 15 technische domeinen.

Wat mij hier opvalt, is de breedte. Het gaat niet om één taal of één type software. Van Python tot minder gangbare talen, van webapplicaties tot systeemtools — de dataset dekt een breed spectrum. Voor de training van AI-agents is die diversiteit waardevol, omdat een agent die alleen Python kent beperkt inzetbaar is in de echte wereld.

Het model dat getraind werd op deze dataset heet MiMo-V2.5. De trainingsmethode is GRPO, een vorm van reinforcement learning — kort gezegd: het model leert door te proberen, feedback te krijgen, en zijn aanpak bij te stellen.

Resultaten: meetbare verbetering op meerdere vlakken

De resultaten zijn concreet en gemeten op vijf verschillende benchmarks. Drie springen eruit:

• DeepSWE (het repareren van softwareproblemen): +11,7% verbetering
• ProgramBench (complete programma's schrijven): +17% verbetering
• Terminal-Bench v2.1 (werken in een terminal-omgeving): +8,5% verbetering

Ik vind het interessant dat de grootste sprong zit bij het schrijven van volledige programma's. Dat is een complexere taak dan een bug fixen, omdat het model een heel ontwerp moet bedenken en uitvoeren. Een verbetering van 17% op die taak is niet triviaal.

De onderzoekers melden ook dat meer taken van hoge kwaliteit direct leidt tot betere prestaties. Dat klinkt logisch, maar het is goed dat het empirisch bevestigd wordt. Het betekent namelijk dat de methode schaalbaar is: hoe meer codebases je erin stopt, hoe beter het model kan worden.

Wat het model anders doet na training

Een detail uit het paper dat ik de moeite waard vind: na de training vertoont het model nieuw gedrag. Het verkent codebases grondiger en gebruikt meer diverse strategieën om zijn eigen werk te controleren. Met andere woorden: het model wordt niet alleen beter in coderen, maar ook in het begrijpen van een project voordat het begint.

Wat betekent dit voor ondernemers?

Nu is een onderzoekspaper natuurlijk nog geen product dat je morgen kunt gebruiken. Maar de richting is relevant voor iedereen die software gebruikt of laat bouwen — en dat zijn de meeste ondernemers.

Er zijn een paar ontwikkelingen die hier samenkomen:

AI-codeertools worden sneller beter

Methodes zoals CodeMidas maken het mogelijk om trainingsdata te genereren op een schaal die met menselijke inspanning niet haalbaar zou zijn. Dat betekent dat de AI-agents achter tools als GitHub Copilot, Cursor en vergelijkbare producten in een hoger tempo kunnen verbeteren. Voor een ondernemer die overweegt om AI-codeertools in te zetten — of dat al doet — is dit een signaal dat die tools de komende tijd merkbaar beter zullen worden.

De drempel voor maatwerk daalt

Stel dat je als MKB-ondernemer een aanpassing nodig hebt aan je bedrijfssoftware. Nu huur je daar een ontwikkelaar voor in, of je vraagt het aan je IT-leverancier. Naarmate AI-agents beter worden in het begrijpen van bestaande code én het schrijven van nieuwe code, wordt het denkbaar dat steeds meer van dat soort taken geautomatiseerd kunnen worden. Niet morgen, maar de trend is zichtbaar.

Diversiteit in talen en domeinen telt

Dat CodeMidas werkt over 23 programmeertalen heen is relevant omdat veel bedrijfssoftware niet in de nieuwste, hipste taal geschreven is. Als AI-agents ook oudere of minder populaire talen goed leren begrijpen, vergroot dat de toepasbaarheid voor bedrijven die met legacy-systemen werken.

Kanttekeningen

Een paar dingen om in het achterhoofd te houden. Ten eerste: de resultaten zijn gemeten op benchmarks, niet in productieomgevingen. Benchmarks geven een indicatie, maar de echte wereld is rommeliger. Ten tweede: het paper vermeldt negentien auteurs, maar ik heb geen institutionele affiliaties kunnen vinden in de beschikbare informatie. Dat maakt het lastig om te beoordelen wie hier precies achter zit en met welke middelen.

Ten derde: het feit dat meer data leidt tot betere resultaten is hoopgevend, maar het roept ook de vraag op wie toegang heeft tot die data en rekenkracht. Open-source codebases zijn voor iedereen beschikbaar, maar de rekenkracht om er duizenden trainingstaken uit te destilleren is dat niet.

Een stille verschuiving

Wat mij het meest bijblijft aan dit paper is niet de percentages, maar het principe. Software leert van software. Er is geen mens nodig om taken te formuleren, tests te schrijven of kwaliteit te controleren — dat doen de agents zelf. Ik denk dat we over een paar jaar terugkijken op dit soort papers als de momenten waarop AI-codeertools de stap maakten van "handig hulpmiddel" naar "zelfstandig inzetbaar". Maar dat is een inschatting, geen zekerheid. Wat ik wel zeker weet: het tempo van verbetering is hoog, en als ondernemer loont het om dat in de gaten te houden.