Sprogets rekursive selvforbedring: Sådan sliber vi Code Intelligence på tværs af ~280 sprog

Tallene i dette indlæg afspejler systemet på udgivelsestidspunktet (maj 2026). Se vores team-side for aktuelle tal.

Maguyva udtrækker symboler, referencer og en afhængighedsgraf fra kildekode på omkring 280 sprog. Hvert sprog er en custom tree-sitter-handler — forespørgsler, heuristikker, kantsager — og enhver handler kan være subtilt forkert på sin egen måde. Et metodekald udsendt som en læsning. En funktion tilskrevet det forkerte omsluttende scope. En relation, der simpelthen ikke findes.

Det kan man ikke håndrevidere. Intet team kan læse udtræksoutput på tværs af 280 grammatikker og spotte de dårlige kanter. Så det interessante spørgsmål er ikke “er vores udtræk korrekt” — det er “hvordan finder man ud af, at det er forkert, i denne bredde, uden et menneske i hver eneste løkke.” Vores svar er sprogets rekursive selvforbedring: en kvalitetsløkke drevet af sprogagenter, en LLM, der agerer dommer, og én regel, vi bliver ved med at genlære: grønt er ikke det samme som korrekt.

Grønt er ikke korrekt

Hvert sprog har en fixture-suite, og en release-gate scorer det på fem dimensioner — nøjagtighed, strukturel integritet, fuldstændighed, kvalitet og performance. Et sprog bliver kun GRØNT, når præcisionen på dets fixtures er ≥ 0.95, recall ≥ 0.99, og F1 ≥ 0.97, med mindst 20 forventede kanter for statistisk konfidens. Under det er det GULT eller RØDT, og det shippes ikke.

Den gate er nødvendig, men ikke tilstrækkelig. Fixtures validerer mod fixtures, vi har skrevet. De indkoder de tilfælde, vi allerede har tænkt på. En handler kan være fejlfri på sine fixtures og stadig ødelægge et mønster, der kun dukker op i rigtig kode — et makro-idiom, en generisk-bundet metode, en sprogfunktion, ingen skrev en fixture til. GRØNT betyder, at fixtures består. Det betyder ikke, at et rigtigt repository udtrækkes rent. Så løkken må lægge fixtures bag sig og se på det vilde.

Den indre løkke: stikprøve, dømme, ret, bevis

Kerneløkken kører ét sprog ad gangen:

        ┌──────────────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          │
  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) ──┘

Et par ting gør, at dette virker i stedet for at hakke rundt.

Dommeren er agenten, ikke et API-kald. Når vi siger “LLM som dommer”, mener vi, at sprogagenten selv læser hver udtaget kant mod den rigtige kilde og klassificerer den med en fast fem-kategoris rubrik: er denne kant korrekt, en falsk positiv, den rigtige relation med den forkerte type, tilknyttet det forkerte scope, eller bærer den forkert metadata? Den rubrik er hele spillet — “23% fejlrate” er meningsløst, indtil man ved, om det er reelle defekter, eller om dommeren tæller forkert.

Ret én ting, og bevis det så. Hver iteration ændrer præcis ét redigerbart asset, kører derefter igen mod en fast harness og beholder kun ændringen, hvis F1 forbedres, og re-klassificeringen ser bedre ud. Hvis ikke, rulles den tilbage. Ingen batch af spekulative rettelser, intet “burde være bedre.” En ændring skal fortjene sin plads, ellers forsvinder den. Og når en rettelse holder, bliver den forfremmet til fixture-suiten — så den fejl, den rettede, aldrig kan snige sig tilbage stiltiende. Det forfremmelsestrin er det, der gør løkken rekursiv frem for bare gentagende: hver omgang hærder det orakel, den næste omgang validerer mod.

Lektien, vi bliver ved med at genlære: metrikker overrapporterer

Her er fælden, og vi gik lige i den. De sekundære korpusmetrikker — hvor ofte et udtrukket mål ikke har noget opløseligt symbol, hvor mange symboler ser “forældreløse” ud, og så videre — overrapporterer massivt problemer. De er for det meste paradigme-artefakter, ikke fejl.

Det reneste eksempel: llvm viste engang en 73% “kilde-uden-symbol”-rate og blev stemplet katastrofal. Vi gravede i det. Den reelle nøjagtighed var 98.5%. De “manglende symboler” var næsten alle legitime eksterne referencer — kald ind i standardbiblioteket, ind i frameworks, ind i kode, der lever uden for repositoriet. Metrikken målte en egenskab ved sproget, ikke en defekt i handleren. Sprog som Zig, COBOL og Odin viser 65–70% “forældreløs”-rater og er fuldstændig korrekte; COBOL havde nul reelle fejl.

Hvis vi havde ladet de tal styre arbejdet, ville vi have brugt uger på at “rette” handlere, der allerede var korrekte, og ignoreret de sprog med stille, reelle fejl. Konklusionen er ligetil: de aggregerede metrikker er højst et groft triage-signal. Det reelle kvalitetssignal er stikprøven med kantklassificering — at se på faktiske kanter i faktiske repositorier og bedømme dem én for én. Data frem for intuition, men kun når man ved, hvilke data der taler sandt.

Den ydre løkke: en flåde, ikke et maraton

Ét sprog ad gangen ville tage evigheder på tværs af 280 af dem, så den indre løkke er pakket ind i en ydre, der kører mange parallelt.

   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

Hver agent arbejder i en engangs-worktree, så de ikke kan træde hinanden over tæerne. Orkestratoren integrerer deres rettelser én ad gangen, hver bag et fuldt manifest-regressionstjek: en ændring, der hjælper sit eget sprog, men stiltiende ødelægger tre andre, lander ikke. Integration er gatet og bekræftet, før noget pushes — regressions-gaten afgør, hvad der er sikkert, et menneske afgør stadig, hvad der shippes. Så roterer poolen til det næste sæt sprog, og det hele kører igen.

Hvad der stadig er ufuldkomment

Dommeren kan tage fejl, og fejlbarheden har en retning: en agent, der kører med for lidt kontekst, overrapporterer. I én batch blev otte sprog flagget med 5–20% fejl; ved nærmere eftersyn var kun ét en reel sprog-specifik fejl — resten var dommerfejl fra at overse sprogets egen semantik (én kildelinje, der legitimt udsender flere kanter, parameterbindinger modelleret som tildelinger, reference-per-identifikator-sprog). Det er derfor, vi udtager stikprøver med to seeds og krydstjekker, og hvorfor en uenighed mellem dommeren og fixtures behandles som det mest interessante signal, ikke en afgjort dom — nogle gange er det fixturet, der tager fejl.

Vi er også ærlige omkring målet. Målet er nul reelle fejl, punktum — men “nul” er en retning, vi sliber os hen imod, sprog for sprog, ikke en boks, der krydses af. Der er altid endnu et repository med endnu et idiom.

Fortjent, ikke påstået

Alt, hvad Maguyva gør for en agent — at finde et symbol, spore en afhængighed, besvare et spørgsmål med citeret kode — hviler på, at udtrækket nedenunder er korrekt. På tværs af 280 sprog kan “korrekt” ikke påstås; det skal løbende fortjenes mod rigtig kode. Løkken er, hvordan vi fortjener det: en autonom stikprøve-og-ret-cyklus, der behandler sine egne metrikker med mistænksomhed, beviser hver ændring og gør hver rettelse til en vagt mod den næste regression. Det er ikke glamourøst. Det er det arbejde, der lader os sige “vi understøtter dit sprog” og mene det. Grønt er nemt. Korrekt er fortjent.