Recursieve zelfverbetering voor taal: Code Intelligence slijpen over ~280 talen

Cijfers in deze post weerspiegelen het systeem op het moment van publicatie (mei 2026). Zie onze teampagina voor actuele cijfers.

Maguyva extraheert symbolen, referenties en een afhankelijkheidsgraaf uit broncode in ruwweg 280 talen. Elke taal heeft een eigen tree-sitter-handler — queries, heuristieken, edge cases — en elke handler kan op zijn eigen subtiele manier fout zitten. Een method-call die als een read wordt uitgezonden. Een functie toegeschreven aan de verkeerde omsluitende scope. Een relatie die er simpelweg niet is.

Dat kun je niet handmatig auditen. Geen team kan extractie-output over 280 grammatica’s lezen en de slechte edges eruit pikken. De interessante vraag is dus niet “klopt onze extractie” — het is “hoe ontdek je dat die fout is, op deze schaal, zonder dat er bij elke lus een mens aan te pas komt.” Ons antwoord is recursieve zelfverbetering voor taal: een kwaliteitslus aangedreven door taalagents, een LLM die als rechter optreedt, en één regel die we steeds opnieuw leren: groen is niet hetzelfde als correct.

Groen is niet correct

Elke taal heeft een fixture suite, en een releasegate scoort die op vijf dimensies — accuratesse, structurele integriteit, volledigheid, kwaliteit en performance. Een taal wordt pas GREEN wanneer, op zijn fixtures, precisie ≥ 0,95, recall ≥ 0,99 en F1 ≥ 0,97 is, met minstens 20 verwachte edges voor statistische betrouwbaarheid. Daaronder is het YELLOW of RED, en wordt het niet uitgeleverd.

Die gate is noodzakelijk maar niet voldoende. Fixtures valideren tegen fixtures die wijzelf hebben geschreven. Ze leggen de gevallen vast waar we al aan hadden gedacht. Een handler kan foutloos zijn op zijn fixtures en toch een patroon verminken dat alleen in echte code voorkomt — een macro-idioom, een generic-bound method, een taalkenmerk waar niemand een fixture voor heeft geschreven. GREEN betekent dat de fixtures slagen. Het betekent niet dat een echte repository netjes extraheert. Dus moet de lus de fixtures achter zich laten en naar het wild kijken.

De binnenste lus: steekproef, beoordelen, repareren, bewijzen

De kernlus draait één taal per keer:

        ┌──────────────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          │
  1. corpus run ── clone real-world repos, extract relationships   │
        │                                                          │
        ▼                                                          │
  2. spot-check 100 edges (seed 42, then seed 123 to cross-check)  │
        │                                                          │
        ▼                                                          │
  3. LLM judge classifies every sampled edge:                      │
        CORRECT · FALSE_POSITIVE · TYPE_ERROR ·                    │
        SCOPE_ERROR · METADATA_ERROR                               │
        │                                                          │
        ▼                                                          │
  4. fix ONE thing — handler .py, .scm query, or config           │
        │                                                          │
        ▼                                                          │
  5. re-validate — F1 + re-classify + manifest diff (no regressions)│
        │                                                          │
   better? ──no──► revert, try a different fix ────────────────────┤
        │ yes                                                       │
        ▼                                                           │
  6. promote the fix into fixtures (a permanent regression guard) ──┘

Een paar dingen zorgen ervoor dat dit werkt in plaats van zinloos ronddraait.

De rechter is de agent, niet een API-call. Met “LLM-as-judge” bedoelen we dat de taalagent zelf elke gesamplede edge naast de echte bron leest en die classificeert volgens een vaste vijfcategorierubriek: is deze edge correct, een fout-positief, de juiste relatie met het verkeerde type, gekoppeld aan de verkeerde scope, of met verkeerde metadata? Die rubriek is het hele spel — “23% foutpercentage” betekent niets totdat je weet of dat echte defecten zijn of dat de rechter verkeerd telt.

Repareer één ding, en bewijs het dan. Elke iteratie wijzigt precies één bewerkbaar asset, draait dan opnieuw tegen een vaste harness, en behoudt de wijziging alleen als F1 verbetert en de herclassificatie er beter uitziet. Zo niet, dan wordt hij teruggedraaid. Geen batch aan speculatieve edits, geen “zou beter moeten zijn”. Een wijziging verdient zijn plek of verdwijnt. En wanneer een fix beklijft, wordt die gepromoveerd naar de fixture suite — zodat de bug die hij verhielp nooit stilzwijgend kan terugkeren. Die promotiestap is wat de lus recursief maakt in plaats van louter herhalend: elke doorgang verhardt het orakel waar de volgende doorgang tegen valideert.

De les die we steeds opnieuw leren: metrieken overrapporteren

Dit is de valkuil, en we liepen er recht in. De secundaire corpusmetrieken — hoe vaak een geëxtraheerd target geen oplosbaar symbool heeft, hoeveel symbolen er “verweesd” uitzien, enzovoort — rapporteren problemen enorm over. Het zijn meestal paradigma-artefacten, geen bugs.

Het duidelijkste voorbeeld: llvm vertoonde ooit een “source-zonder-symbool”-percentage van 73% en werd tot catastrofaal bestempeld. We doken erin. De werkelijke accuratesse was 98,5%. De “ontbrekende symbolen” waren bijna allemaal legitieme externe referenties — calls naar de standaardbibliotheek, naar frameworks, naar code die buiten de repo leeft. De metriek mat een eigenschap van de taal, geen defect in de handler. Talen zoals Zig, COBOL en Odin vertonen “orphan”-percentages van 65–70% en zijn volkomen correct; COBOL had nul echte fouten.

Als we die cijfers het werk hadden laten sturen, hadden we weken besteed aan het “repareren” van handlers die al klopten, terwijl we de talen met stille, echte bugs negeerden. De conclusie is bot: de geaggregeerde metrieken zijn hoogstens een ruw triagesignaal. Het echte kwaliteitssignaal is de steekproef met edge-classificatie — kijken naar daadwerkelijke edges in daadwerkelijke repositories en ze één voor één beoordelen. Data boven intuïtie, maar alleen zodra je weet welke data de waarheid vertelt.

De buitenste lus: een vloot, geen marathon

Eén taal per keer zou eeuwig duren over 280 talen, dus wordt de binnenste lus omhuld door een buitenste die er veel parallel draait.

   pick a wave of near-GREEN / high-error languages
        │
        ▼
   fan out 10–15 agents, each ISOLATED in its own git worktree,
   each grinding ONE language, committing to its own branch
        │
        ▼
   orchestrator integrates serially: file-scoped apply, then
   `manifest diff` — any cross-language regression blocks the batch
        │
        ▼
   gated push (reviewed and confirmed) ──► rotate to the next wave

Elke agent werkt in een wegwerp-worktree, zodat ze elkaar niet voor de voeten lopen. De orchestrator integreert hun fixes één voor één, elk achter een full-manifest-regressiecheck: een wijziging die zijn eigen taal helpt maar stilzwijgend drie andere breekt, landt niet. Integratie wordt bewaakt en bevestigd voordat er iets wordt gepusht — de regressiegate bepaalt wat veilig is, een mens beslist nog altijd wat wordt uitgeleverd. Vervolgens roteert de pool naar de volgende set talen en draait het geheel opnieuw.

Wat nog altijd niet perfect is

De rechter kan het mis hebben, en die fout heeft een richting: een agent die met te weinig context draait overrapporteert. In één batch werden acht talen gemarkeerd met 5–20% fouten; bij inspectie bleek er maar één echte taalspecifieke bug te zijn — de rest waren beoordelingsfouten doordat de eigen semantiek van de taal werd gemist (één brontekstregel die legitiem meerdere edges uitzendt, parameterbindingen gemodelleerd als assignments, talen met een reference-per-identifier-patroon). Daarom samplen we met twee seeds en kruiscontroleren we, en daarom wordt een meningsverschil tussen de rechter en de fixtures behandeld als het meest interessante signaal, geen definitief oordeel — soms is de fixture het ding dat fout zit.

We zijn ook eerlijk over het doel. Het doel is nul echte fouten, punt — maar “nul” is een richting waar we naartoe blijven slijpen, taal voor taal, geen vakje dat je afvinkt. Er is altijd nog een repo met een ander idioom.

Verdiend, niet beweerd

Alles wat Maguyva voor een agent doet — een symbool vinden, een afhankelijkheid traceren, een vraag beantwoorden met geciteerde code — rust op de extractie eronder die klopt. Over 280 talen kan “klopt” niet worden beweerd; het moet voortdurend worden verdiend tegen echte code. De lus is hoe we het verdienen: een autonome steekproef-en-repareer-cyclus die zijn eigen metrieken met argwaan behandelt, elke wijziging bewijst, en elke fix omzet in een bewaker tegen de volgende regressie. Het is niet glamoureus. Het is het werk dat ons in staat stelt te zeggen “we ondersteunen jouw taal” en dat te menen. Groen is makkelijk. Correct is verdiend.