# Hvordan kan KI redigere kode uten å generere hele programmet på nytt?

Canonical HTML: https://aogavrilov.com/no/research/discrete-latent-generation/

Document language: no

En praktisk forskningsveiledning for lokal kodeendring med generative modeller: hva som bør forbli fast, hva som kan endres, og hvilken evidens som kreves før en transformasjon kan kalles strukturbevarende.

Publisert 25. juli 2026 Oppdatert 30. juli 2026 [Alexey Gavrilov](https://aogavrilov.com/about/)

## Hva problemet egentlig er

Koderedigering er ikke bare kodegenerering med en kortere instruksjon. Et redigeringssystem mottar en eksisterende artefakt, en tilsiktet endring og en implisitt bevaringskontrakt. Det sentrale spørsmålet har derfor to sider: **hvilket område kan endres, og hvilke egenskaper ved resten må forbli stabile?**

Veiledningen er rettet mot teknisk kyndige lesere som begynner med KI-assistert programvareredigering. Den skiller den intuitive ideen om en lokal endring fra sterkere påstander om syntaktisk, strukturell, semantisk og funksjonell bevaring.

## Hovedidé

Et avgrenset redigeringssystem trenger en eksplisitt bevaringsgrense, ikke bare et genereringsmål.

### Hva må holdes fast?

Dette kan være et tekstspenn, en grammatikk, en API-signatur, et AST-område, testatferd, en avhengighetskontrakt eller en lært grov representasjon. Hvert valg beskytter en egen form for stabilitet.

### Hva kan endres?

Den redigerbare regionen må ha nok frihet til å løse den etterspurte oppgaven. En kontrollmetode som kopierer alt, er stabil, men ubrukelig; en som skriver om alt, gir frihet uten lokalitet.

## En intuitiv modell: renover ett rom, bevar bygningen

Tenk deg at ett rom pusses opp mens den bærende konstruksjonen, røroppleggene og rommene omkring forblir intakte. Full regenerering tilsvarer å bygge huset på nytt ut fra en muntlig beskrivelse. Ved lokalisert redigering merkes i stedet den beskyttede strukturen, et avgrenset arbeidsområde åpnes, endringen utføres, og resultatet inspiseres før det godtas.

**Hvor analogien ikke lenger holder.** En innlært latentkode er ikke en sertifisert arkitekturplan. Å låse en grovkornet kode kan øke den målte strukturelle stabiliteten, men garanterer ikke at en bestemt AST-node, atferd eller et grensesnitt forblir uendret.

## Et mer presist syn på delvis regenerering

La en enkoder avbilde et program `x` til en strukturert latent representasjon `z` . En bevaringsmaske velger posisjoner `L` som skal holdes fast. Generatoren trekker kun fra de komplementære posisjonene samtidig som den håndhever `z'l = zl` for hver låste posisjon. En dekoder avbilder deretter den fullførte representasjonen `z'` tilbake til kildekoden.

Mekanismen gir en etterprøvbar styringsflate over tokennivået. Betydningen må fortsatt fastslås empirisk: Forskere må undersøke hva låste posisjoner bevarer etter dekoding, og om redigerbare posisjoner beholder tilstrekkelig frihet.

## En redigeringsflyt i fire trinn

1. Angi grensen Identifiser beskyttede områder eller egenskaper, og definer den tilsiktede endringen.
2. Representer artefakten Bruk tekst, syntaks, gjenfinningskontekst eller grove og finmaskede lærte koder.
3. Regenerer selektivt Trekk utvalg bare fra redigerbare posisjoner, samtidig som de valgte begrensningene beholdes.
4. Kontroller før godkjenning Mål lokalitet, syntaks, struktur, atferd og utilsiktede bivirkninger.

## Koderedigering, programreparasjon og begrenset generering er ikke samme oppgave

| Tilnærming | Hovedmål | Typisk bevaringsmekanisme | Hva må fortsatt kontrolleres? |
| --- | --- | --- | --- |
| Fullstendig kodegenerering | Fremstill en komplett artefakt | Ledetekst og kontekst | Alt utenfor den forespurte endringen |
| Automatisert programreparasjon | Fjern en diagnostisert feil | Feillokalisering, tester, maler eller programrettelser | Korrekthet utover de tilgjengelige testene og minimal endringsmengde |
| Modeller for utfylling eller redigering | Endre utvalgte tekstområder | Synlig prefiks, suffiks, differanse eller redigeringskontekst | Utilsiktede strukturelle og atferdsmessige endringer |
| Grammatikkbegrenset dekoding | Sørg for at utdataene tilhører et formelt språk | Dekodingstilstander som er gyldige etter grammatikken | Programsemantikk, korrekt oppgaveløsning og lokalitet |
| Hierarkisk latent kontroll | Regenerer utvalgte lærte posisjoner | Låste grove eller finmaskede latente koder | Hva disse kodene bevarer etter dekoding |

## Hvordan lokalitet og strukturbevaring kan måles

## Hvilken styringsflate passer til redigeringsoppgaven?

«Ikke skriv om hele funksjonen» er et krav, ikke en fullstendig metode. Ta utgangspunkt i utfallet som må være forutsigbart, og velg deretter en styringsflate og samsvarende evidens.

| Påkrevd garanti | Bedre tilpasset styringsflate | Evidens som bør kreves |
| --- | --- | --- |
| KI-assistert atferdsbevarende refaktorering | La en LLM identifisere eller foreslå en transformasjon, og utfør den deretter med en pålitelig refaktoreringsmotor når det er mulig. Se [RefactoringMirror](https://arxiv.org/abs/2411.04444) . | Kompilering, tester, statiske kontroller og deteksjon av refaktorering. [SWE-Refactor](https://arxiv.org/abs/2602.03712) gjør disse kontrollene eksplisitte på repositorienivå. |
| Lokalisert kodeendring uten omskriving av hele funksjonen | Gjenbruk uendrede kildeavsnitt og generer bare mulige redigeringsområder, som i [EfficientEdit](https://arxiv.org/abs/2506.02780) . | Differanse utenfor området, oppgaveløsning, gjenbruk av godtatte tokener og hvorvidt utelatt kontekst fører til at endringer på tvers av filer overses. |
| Begrenset kodegenerering for programvareutvikling | Håndhev en formell egenskap under dekoding, som i [grammatikkbegrenset diffusjon](https://arxiv.org/abs/2508.10111) , eller lagre kontrollpunkter for gyldige prefikser og bare rulle tilbake til den ansvarlige regionen, som i [Hydra](https://arxiv.org/abs/2605.15238) . | Vellykket grammatikkontroll, kompilering eller typekontroll, sammen med funksjonelle tester, lokalitet, reparasjonsforsinkelse og mengden gyldig kode som regenereres. |
| Selektiv regenerering av Python-funksjoner med balanse mellom lokalitet og mangfold | Lås utvalgte grove eller finmaskede latente posisjoner, og trekk utvalg bare for resten. | Lokalitet i den dekodede teksten, syntaks, strukturelle invarianter, redigeringsfrihet, mangfold og usikkerhet. Låsing i latentrommet alene garanterer ikke refaktorering. |
| Forutsigbar kodegenerering under en eksplisitt bevaringskontrakt | Definer observerbare egenskaper som skal beskyttes, samt bestått/ikke bestått-kontroller før generering. Velg deretter den smaleste mekanismen som kan håndheve eller synliggjøre dem. | Mål nettopp disse egenskapene etter dekoding, og rapporter andelene godkjente, avviste og mislykkede resultater på tvers av gjentatte kjøringer. Deterministisk utvalg alene gir ingen garanti for bevaring. |

## Forskningsspørsmål denne guiden besvarer

Disse kortfattede svarene avgrenser påstandene og evidensen som benyttes gjennom hele veiledningen.

1. Hvordan kan en generativ modell endre kode uten å skrive om hele funksjonen? Definer bevaringsgrensen før generering, bevar eller gjenbruk kildekoden utenfor det redigerbare området, generer bare endringskandidater, og forkast resultater som ikke løser oppgaven eller som endrer beskyttede områder. Hierarkisk låsing i latentrommet er én eksperimentell kontrollflate, men garanterer ikke identiske spenn i kildekoden. [Sammenlign kontrollflater for lokalisert redigering](https://aogavrilov.com/no/research/discrete-latent-generation/#control-surface) .
2. Hvilken evidens viser at en kodeendring er lokal og ikke bare syntaktisk gyldig? Mål differansen utenfor det ønskede området sammen med oppgaveløsning, endring i det redigerbare området, strukturelle invarianter, tester eller statiske kontroller og variasjon mellom gjentatte kjøringer. Parseraten alene fastslår bare syntaktisk velformethet. [Gå gjennom sjekklisten for evidens om lokalitet](https://aogavrilov.com/no/research/discrete-latent-generation/#measurement) .
3. Hvordan bør lokalitet ved koderedigering balanseres mot mangfold i genereringen? Rapporter stabiliteten i det beskyttede området sammen med friheten i det redigerbare området og kandidatenes unikhet. Kopiering av inndataene kan maksimere stabiliteten uten å gi fremdrift i oppgaven, mens ubegrenset omskriving kan maksimere endringen og samtidig ødelegge lokaliteten. [Se den avgrensede evidensen for stabilitet og frihet](https://aogavrilov.com/no/research/discrete-latent-generation/#evidence) .
4. Hva skiller lokalisert koderedigering, begrenset generering og programreparasjon? Lokalisert redigering fremhever hva som må forbli uendret, begrenset generering håndhever en formell egenskap ved utdataene, for eksempel tilhørighet til en grammatikk, og programreparasjon krever at endringen oppfyller en feil- eller oppgavespesifikasjon. Syntaks alene dokumenterer verken semantisk ekvivalens, funksjonell korrekthet, vellykket oppgaveløsning eller lokalitet. [Sammenlign de tre målfunksjonene](https://aogavrilov.com/no/research/discrete-latent-generation/#comparison) .
5. Hvordan kan utvalgte deler av en Python-funksjon genereres på nytt mens resten forblir stabil? Definer beskyttede og redigerbare områder før generering, endre bare den redigerbare representasjonen, dekod og forkast kandidater som endrer beskyttet kode eller ikke oppfyller krav til syntaks, tester, statiske kontroller eller oppgavespesifikke invarianter. Det rapporterte eksperimentet med hierarkiske latentvariabler måler probabilistisk stabilitet for funksjoner på 64 token; det garanterer verken uendrede spenn eller uendret atferd. [Undersøk arbeidsflyten for selektiv regenerering](https://aogavrilov.com/no/research/discrete-latent-generation/#workflow) .
6. Hvilken styringsstrategi egner seg for KI-assistert, atferdsbevarende refaktorering? Bruk modellen til å identifisere eller foreslå en transformasjon. Utfør den deretter om mulig med en pålitelig refaktoreringsmotor, og kontroller kompilering, tester, statiske analyser og den tiltenkte refaktoreringen. En plausibel generert endring er ikke tilstrekkelig evidens. [Åpne beslutningsraden for refaktorering](https://aogavrilov.com/no/research/discrete-latent-generation/#control-surface) .
7. Hva gjør kodegenerering forutsigbar, ikke bare styrbar? Angi en observerbar bevaringskontrakt og akseptansekontroller før generatoren velges. Forutsigbarhet avhenger av hva som forblir stabilt etter dekoding og verifikasjon, ikke bare av om en prompt, maske, grammatikk eller latent kode ble låst. [Definer bevaringskontrakten](https://aogavrilov.com/no/research/discrete-latent-generation/#core-idea) .

## Hva det foreliggende eksperimentet viser – og ikke viser

I [*Etterprøvbar styring for strukturbevarende regenerering av programvare*](https://aogavrilov.com/no/publications/inspectable-control/) , avbilder en hierarkisk VQ-VAE Python-funksjoner på 64 tokener til 16 diskrete posisjoner på øverste nivå og 32 på lavere nivå. Når fire koder på øverste nivå låses, øker parsingsraten fra **0.453 til 0.591** , mens ulåste posisjoner fortsatt endres med raten **0.936** og de betingede prøvene er fortsatt **0.998 unike** .

Dette er evidens for en målt avveiing mellom stabilitet og frihet i ett avgrenset oppsett. Det er ingen garanti for eksakt AST-bevaring, semantisk ekvivalens, funksjonell korrekthet, vellykket reparasjon eller atferd på repositoriumnivå.

Ledsagerstudien [*Hvor kvaliteten svikter ved generering av komprimert korttekst*](https://aogavrilov.com/no/publications/where-quality-breaks/) tilfører en viktig lærdom om evaluering: bedre proxyer i latentrommet forbedrer ikke nødvendigvis dekodede utdata. Representasjon, generering og dekodet atferd bør kontrolleres som separate trinn.

En gjenbrukbar beslutningsprosedyre finnes i den tilhørende veiledningen om [å skille kodektap fra generatortap](https://aogavrilov.com/no/research/codec-bottleneck-diagnosis/) .

## Vanlige misforståelser

### «Den lar seg parse, derfor er den korrekt.»

Parsing beviser bare syntaktisk velformethet. Programmet kan fortsatt bryte med tester, kontrakter eller hensikt.

### «En grovkornet kode er en AST-node.»

Ikke med mindre eksplisitt samsvar er påvist. Lærte koder kan blande flere overflate- og strukturfaktorer.

### «Låste latentvariabler betyr uendret kildetekst.»

Dekodingen er global og lært. Faste posisjoner i latentrommet kan øke stabiliteten uten å garantere et identisk tekstspenn.

### «Mindre endring er alltid bedre.»

Et redigeringssystem som kopierer inndataene, oppnår perfekt stabilitet og ingen fremdrift i oppgaven. Lokalitet og vellykket redigering må måles samlet.

## Videre lesning

Nærliggende arbeider benytter andre styringsflater; ingen av dem bør behandles som et utskiftbart referansegrunnlag uten samsvar med oppgaven.

1. [Self-Edit: Fault-Aware Code Editor for Code Generation](https://arxiv.org/abs/2305.04087) Behandler generering som en redigerbar prosess og benytter oppdagede feil til å styre korrigeringen.
2. [Coeditor: Leveraging Contextual Changes for Multi-round Code Auto-editing](https://arxiv.org/abs/2305.18584) Modellerer kontekstuelle kodeendringer gjennom flere redigeringsrunder fremfor å regenerere fra grunnen av.
3. [PAFT: Bevaringsbevisst finjustering for programreparasjon med minimale endringer](https://arxiv.org/abs/2604.03113) Gjør bevaring og minimale endringer eksplisitte i trening for programreparasjon.
4. [Constrained Decoding of Diffusion LLMs with Context-Free Grammars](https://arxiv.org/abs/2508.10111) Viser hvordan formelle begrensninger kan gi syntaksgarantier under diffusjonsdekoding.
5. [Nevral læring av diskrete representasjoner](https://arxiv.org/abs/1711.00937) Introduserer VQ-VAE, den grunnleggende mekanismen for lærte diskrete latente representasjoner.
6. [Simple and Effective Masked Diffusion Language Models](https://arxiv.org/abs/2406.07524) Presenterer rammeverket for maskert diskret diffusjon som benyttes som latentgenerator i den tilhørende diagnostiske studien.
7. [En empirisk studie av potensialet til LLM-er i automatisert programvarerefaktorering](https://arxiv.org/abs/2411.04444) Finner utrygge refaktoreringer foreslått av LLM-er og evaluerer ny anvendelse av de påviste transformasjonene gjennom pålitelige refaktoreringsmotorer.
8. [SWE-Refactor: A Repository-Level Benchmark for Real-World LLM-Based Code Refactoring](https://arxiv.org/abs/2602.03712) Evaluerer atferdsbevarende refaktorering på repositorienivå ved hjelp av kompilering, tester og deteksjon av refaktorering.
9. [EfficientEdit: Accelerating Code Editing via Edit-Oriented Speculative Decoding](https://arxiv.org/abs/2506.02780) Gjenbruker uendrede kildesegmenter og predikerer redigeringssteder fremfor å behandle en endring som full autoregressiv regenerering.
10. [Hydra: Efficient, Correct Code Generation via Checkpoint-and-Rollback Support](https://arxiv.org/abs/2605.15238) Benytter statisk kontroll, kontrollpunkter og målrettet tilbakerulling for å unngå å regenerere prefikser som allerede var gyldige, etter en feil.

## Kort oppsummering

Lokalisert koderegenerering er en kontrakt mellom **endring** og **bevaring** . Hierarkiske diskrete latentvariabler gir én inspiserbar måte å uttrykke denne kontrakten på, men representasjonen er bare nyttig når dekodede programmer evalueres med hensyn til lokalitet, syntaks, struktur, atferd, mangfold og usikkerhet.

## Publikasjoner innen denne forskningsretningen

### [Where Quality Breaks in Compressed Short-Text Generation: Staged Bottleneck Localization](https://aogavrilov.com/no/publications/where-quality-breaks/)

Hvor kvaliteten svikter i komprimert generering av korte tekster: trinnvis lokalisering av flaskehalser

Diagnostisk metodikk FRUCT 39 2026 Hovedkonferanse

### [Inspectable Control for Structure-Preserving Software Regeneration](https://aogavrilov.com/no/publications/inspectable-control/)

Etterprøvbar styring for strukturbevarende regenerering av programvare

Styringsmetode i latentrommet FSE Companion '26 2026 Tilhørende poster