Jeg har kodet siden jeg var en knægt, men for nylig byggede jeg min første lille dims udelukkende ved hjælp af ChatGPT (eller teknisk set: Claude). Ret vild oplevelse.

Det hele startede egentlig lidt tilfældigt. Jeg sad i vores innovationslaboratorium og eksperimenterede med automatisk oversættelse mellem forskellige sprog. Jeg havde brug for et lille program til en prototype, hvor det skulle kunne oversætte i realtid mellem f.eks. dansk og urdu. Det virkede fint - en enkel kommandolinje-app, hurtig at lave og præcis nok til formålet.

Det så cirka sådan ud. Bemærk, at hver linjer starter med at registrere det talte sprog:

Men så skulle jeg bruge den til et kundemøde. Og der er alligevel noget lidt… antiklimaktisk over at præsentere noget i en sort konsol. Så jeg tænkte: mon ikke Claude kan hjælpe?

Jeg copy-pastede min kode ind og skrev noget i stil med: ”Lav det her om til en webapp.” Bum. Det virkede. Den kom stort set med en færdig løsning i første hug — jeg rettede én lille ting, og så kørte det. Layoutet var endda pænere, end jeg selv ville have fundet på i en prototype. Pludselig havde jeg noget, der faktisk kunne vises frem. Nu så det pludselig sådan ud.

Herfra gik det stærkt.

Jeg begyndte at lægge små forbedringer ind. Ikoner, så man kunne se, hvem der taler? Et par linjer i Claude. Farvekoder, der viser oversættelseskvalitet? Fint, det får du også. Jeg sad nærmest måbende og så det hele blive bygget foran mig, mens jeg bare holdt retningen.

Flowet

Det praktiske setup var enkelt: Jeg havde Visual Studio, som jeg normalt koder i, åbent på den ene skærm og Claude i browseren på den anden. Når jeg ville ændre noget, vedhæftede jeg filen og beskrev det i Claude, som så skrev en ny version af filen. Jeg copy-pastede den tilbage, trykkede F5 – og så kørte det.

Hvis der var fejl, kopierede jeg dem tilbage til Claude, som rettede dem. Det var næsten som at sidde med en assistent, der skrev det hele, mens jeg bare holdt overblikket. En lille stemme bagerst i hovedet spurgte: Er det her egentlig omvendt pair programming? Er det mig, der er co-piloten nu?

Og det gik hurtigt. Virkelig hurtigt. Jeg kunne iterere i et tempo, der normalt ville kræve et lille team. Jeg sad med følelsen af at være en lille baron, der bare skulle holde styr på visionen, mens maskinen tog sig af detaljerne.

Men så...

Det begyndte som en lille hakken i flowet. En fejl, der dukkede op, da jeg testede en ny funktion. Jeg kopierede den over til Claude, som plejede at fikse den slags uden problemer. Den kom tilbage med en rettelse. Jeg indsatte rettelsen, trykkede F5... og fik en ny fejl.

Nå, okay. Tilbage til Claude. Ny rettelse.

Endnu en fejl.

Jeg begyndte at fornemme det, man godt ved, når man har prøvet det før: Jeg havde mistet overblikket. Koden var vokset til 2.500 linjer. Jeg havde ikke skrevet den. Jeg kunne selvfølgelig godt læse den; koden var sådan set i nogenlunde kvalitet — men jeg forstod den ikke i kroppen. Den var ikke min. Og rundt omkring var der mærkværdigheder, som det ville tage lang tid at forstå logikken i.

Jeg scrollede ned gennem filen. Et stykke genereret spaghetti, der snoede sig rundt om sig selv med async-kald, event handlers og en række logikker, jeg ikke kunne se enden på. Et sted i midten anede jeg, at der gemte sig en race condition. Men præcis hvor? Det var som at forsøge at finde en løs ledning i et sammenfiltret net af kabler uden farvekoder.

Jeg spurgte Claude: “Kan det her være en race condition?” Den svarede høfligt ja (Claude siger som regel ja, så det var egentlig ikke nogen hjælp i sig selv). Og så prøvede den at rette det. Resultatet? En ny version… med en ny type fejl. Jeg kunne mærke det begynde at trække tænder ud.

Samtidig begyndte ventetiden at vokse. Nu var min fil jo løbende vokset til flere tusinde linjer. Det tog 10 minutter for Claude at skrive filen om. Hver gang den skulle ændre noget. Og så 10 minutter mere, når en fejl i den nye version skulle rettes. Jeg sad og kiggede på fremskridtsbjælker og tænkte, at det var lidt som at få en superbil, der skulle til service efter hver kilometer.

På et tidspunkt sad jeg bare og stirrede på koden og indså: Jeg bliver nødt til selv at fikse det her.

Jeg gravede mig ned i det. Gik systematisk frem. Kommenterede sektioner ud, lavede små testændringer, til jeg kunne isolere fejlen. Og da jeg endelig fandt det — det lille usynlige kapløb mellem to tråde, der ikke altid nåede frem i samme rækkefølge — var det faktisk ikke svært at rette. Det krævede bare, at nogen havde øje for det. I dette tilfælde et menneskeøje.

Jeg prøvede først Claude af. Hey, Claude - her er fejlen. Go fix. Men jeg endte tilbage i samme loop. Den var simpelthen ikke i stand til at rette fejlen, uanset hvor åbenlyst jeg gjorde opmærksom på den.

Og det viste sig også ikke at være en enlig svale. Jeg havde den slags oplevelser en håndfuld gange i forløbet.

Så hvad lærte jeg?

Jeg kommer helt sikkert til at gøre det igen. At bygge med AI på den måde var hurtigt, effektivt – og overraskende tilfredsstillende. Men oplevelsen rykkede også ved noget mere grundlæggende: Rollen som udvikler er ved at forandre sig.

Vi er vant til at tænke os selv som piloten: Den, der har hænderne på styrepinden og bygger tingene op fra bunden. Men i det her setup er det fristende at glide over i rollen som co-pilot. Man beskriver, hvad man vil, og ser systemet levere. Og så nikker man lidt og går videre. Men det er en farlig komfort.

For det kræver faktisk en ret målrettet indsats at blive ved med at være pilot, når maskinen gerne vil overtage styretøjet. Det kræver, at man tager ansvar for arkitekturen, udfordrer forslagene, reviewer med kritisk blik og insisterer på at forstå, hvad der foregår, også tager ansvar for at refaktorisere og omstrukturere koden løbende. Ikke bare acceptere det output, man får.

Og det kræver, at vi udviklere vænner os til noget nyt: At en stor del af arbejdet fremover vil handle om at læse, strukturere og kvalitetssikre kode, vi ikke selv har skrevet. Vores faglighed flytter sig – fra at være “skribent” til at være “redaktør”. Fra at være håndværker til at være systemtænker. Og det er ikke en passiv opgave. Det kræver overblik, dømmekraft og vilje til at tage lederskab.

Men hvad så med junior-udvikleren, der sidder i sit første job og er ved at lære at kode? Her bliver billedet endnu mere komplekst. For når man fra dag ét kan få systemet til at generere fuldt fungerende kode, hvordan lærer man så selve håndværket? Hvordan bliver man nogensinde pilot? Det svarer lidt til at give lommeregnere til børn i 3. klasse og håbe, de lærer matematik af det. Nogle gør. Men mange lærer bare at taste på lommeregneren.

Og det er måske i virkeligheden både det spændende og det skræmmende ved den her udvikling: at mange vil kunne producere kode uden nogensinde at lære at kode. Og samtidig: at det bliver endnu mere værdifuldt at kunne tænke som en udvikler. At forstå, hvad god arkitektur er. At gennemskue problemer, før de opstår. At se det, AI’en ikke selv kan se.

Så ja – jeg er vild med perspektiverne i den her måde at arbejde på. Men kun hvis vi bliver ved med at holde fast i pilotrollen. For nogen skal sætte retningen. Nogen skal forstå det hele. Og det ansvar kan man ikke automatisere.