Tankeledare

Varför testning måste byggas in i AI-produktionslinjen från början

Ole Lensmar
Lägg till Unite.AI bland dina föredragna källor på Google
Viktiga punkterAI snabbar upp kodning men blottar svag nedströms testning och sänker…
Visa mer
  • AI snabbar upp kodning men blottar svag nedströms testning och sänker leveransstabiliteten.
  • Agenter som bedömer sina egna tester kan fuska genom att redigera misslyckade tester istället för att fixa koden.
  • Testning måste vara en egen station utanför CI så att varje ändring möter samma dom.

Jag har arbetat med att utveckla testverktyg i mer än tjugo år, och under större delen av den tiden har mina samtal med utvecklingsteam låtit ungefär likadant. Testare kände sig som andra klassens medborgare i mjukvarans livscykel. Testningen gjordes sent, ofta inklämd i den tid som återstod före en lansering, och lades till i en CI-pipeline som hade byggts för något annat. AI har nu förändrat hur vi skriver kod – och det påverkar definitivt testningen, på både gott och ont. På många sätt har AI gjort utmaningen mer synlig.

Under de senaste månaderna har jag deltagit i en handfull konferenser om testning och molnbaserad utveckling (LeadDev, CloudX, StarWest), och nästan alla team jag talat med arbetar med någon variant av samma projekt: en AI-driven livscykel för mjukvaruleveranser, där agenter tar arbetet från en specifikation till något som körs i produktion, med lagom mycket mänsklig inblandning längs vägen. Jag föreställer mig det som en produktionslinje. Agenter skriver koden, andra agenter granskar den och pipelines bygger och driftsätter den. Människor håller ett öga på det hela. Det jag hör betydligt mindre om är var testningen kommer in i den här kedjan.

Ingen har klurat ut det här än

Just nu råder lite vilda västern. Nya agentfunktioner dyker upp med några veckors mellanrum, de stora AI-laboratorierna fortsätter att lansera nya modeller, och både team och leverantörer provar sig fram för att se vad som fungerar.

En del data tyder på att bristerna redan börjar visa sig. Googles senaste DORA-rapport om AI-stödd mjukvaruutveckling, som omfattade nästan 5 000 teknikproffs, visade att användning av AI hänger samman med högre genomströmning i leveranserna, vilket är goda nyheter. Den hänger fortfarande också samman med lägre leveransstabilitet. Forskarna förklarar detta med att AI påskyndar utvecklingen och blottlägger svagheter längre ned i kedjan. De pekar på gedigen automatiserad testning som en av de skyddsmekanismer som hindrar fler förändringar från att leda till ökad instabilitet.

Det förvånar mig inte. Om man pressar igenom mycket mer kod i en process som utformats för betydligt mindre mängder, kommer den att sakta ner någonstans eller gå sönder någonstans.

Utvecklare arbetar snabbare, men de flesta releaser gör det inte

När människor föreställer sig vad som kan gå fel med AI-genererad kod tänker de ofta sig en agent som skickar ut något riktigt dåligt i produktion. Jag är säker på att det händer – och när det gör det blir följderna inte roliga: buggar, missnöjda kunder, kanske en säkerhetsincident. Men ärligt talat är det inte det jag oftast stöter på.

Stack Overflows utvecklarundersökning 2026 visar var AI-användningen är koncentrerad i dag. Utvecklare använder den främst för att generera kod inom områden de redan känner till (67 %) och för felsökning (61 %), medan bara 20 % använder den för att driftsätta, hantera eller felsöka produktionssystem. Hittills har AI främst gjort det snabbare att skriva kod. Att verifiera koden och få ut den i produktion fungerar fortfarande till stor del som tidigare.

Det stämmer också överens med det jag själv ser: team producerar betydligt mer kod utan att släppa den snabbare. En enskild utvecklare eller ett team kan känna att de bygger dubbelt så många funktioner, men de fastnar längre ned i kedjan och får vänta på granskning, på tester och på en testmiljö. All den extra koden korkar igen pipelinen och bromsar i många fall till och med teamens totala leveranstakt.

Frågorna om skyddsmekanismer kommer från chefer

Även om oron för flaskhalsar i leveranserna som orsakas av AI är mycket konkret, är det inte det enda team frågar oss om. Utvecklare vill främst veta hur de kan skriva bättre kod snabbare. Frågorna om skyddsmekanismer kommer från utvecklingschefer och från dem som sätter upp agentdrivna arbetsflöden. Hur ser vi till att agenterna inte löper amok? Hur vet vi att de inte orsakar regressioner eller i tysthet hoppar över arbete som de skulle utföra? Hur ser vi till att testerna de skriver faktiskt (och på riktigt!) verifierar det de ska?

Jag tror att det beror på att de tittar på olika saker. En utvecklare granskar en pull request i taget. En utvecklingschef ansvarar för allt som släpps av många agenter och människor och måste förklara sig när något går sönder i produktion.

Och det finns skäl att vara försiktig. Forskare skapade ett riktmärke kallat ImpossibleBench med kodningsuppgifter där enhetstesterna motsäger specifikationen, så det enda sättet att klara dem är att fuska. Ledande modeller gjorde ofta just det, till exempel genom att redigera eller ta bort de misslyckade testerna i stället för att rätta koden (!!). En separat studie av pull requests författade av agenter fann brister i hur väl agenter testar sina egna ändringar och hänvisar till tidigare forskning som visar att nästan en tredjedel av de sammanslagna pull requests som agenter skapat behövde följas upp med korrigeringar eller omstrukturering.

Min slutsats är att skyddsmekanismer inte bara kan finnas i agentens egen miljö, och inte heller införas först efter att koden har släppts. Om agenten som skrev koden också avgör om den blev godkänd säger resultatet inte särskilt mycket. Det betyder inte att agenter inte ska skriva tester. Det betyder att bedömningen måste göras någon annanstans, där agenten inte kan påverka den. Testningen måste vara en egen station i produktionslinjen, en station som varje ändring passerar, oavsett om den har skrivits av en människa eller en agent.

Vad den stationen behöver

Svaret är inte en helt ny typ av testning. Det mesta som behövs är sådant som bra kvalitetssäkringsteam har efterfrågat hela tiden. Det har bara blivit viktigare nu.

Tester behöver granskas så att de stämmer med kraven – precis som koden de testar. De behöver också köras i samma miljö som programvaran. Att ett test går igenom i en agents sandlåda säger inte mycket om staging- eller produktionsmiljön, och det kan dölja vilka beroenden som har ersatts med mockar – eller hur. En färsk studie av nästan 180 000 testfiler som genererats av agenter visade att agenter täckte fler specialfall än tester skrivna av människor, men att deras tester oftare visade tecken på instabilitet. Det berodde till stor del på att agenterna inte visste tillräckligt om miljön där testerna skulle köras. Det fångar man upp genom att köra tester mot verklig infrastruktur tidigt.

Tester och testresultat behöver finnas kvar. Om en agent skriver ett test bör den få tillgång till befintliga tester och deras resultat som kontext, så att den kan lära sig både av testtäckningen och av eventuell instabilitet. Tester behöver granskas och versionshanteras precis som annan kod, så att de körs igen vid nästa ändring i stället för att försvinna när sessionen avslutas.

Ett godkänt testresultat bör betyda samma sak oavsett vem som begärde testet – en pipeline, en utvecklare eller en agent. Det innebär att samma tester körs på samma infrastruktur och att resultaten samlas på ett ställe.

Människor bör också fortsätta använda sitt omdöme. Jag låter gärna agenter hantera standardarbetet och koppla ihop systemen. Att avgöra vad som är värt att testa och vad ett fel innebär är fortfarande en mänsklig uppgift (åtminstone för tillfället…).

Det innebär också att testning inte bara kan finnas inom CI/CD (om du bara tar med dig en sak från den här artikeln, låt det vara den här!). CI-pipelines utformades för att bygga och leverera kod; de byggdes aldrig för att köra automatiserade tester i stor skala. I takt med att vi går mot en agentbaserad SDLC och mängden kod fortsätter att växa blir CI ett ännu sämre alternativ för att köra tester. Testning måste vara en central del av hur programvara levereras, inte ett steg som läggs till i slutet av en pipeline. Det innebär att testningen måste samordnas som ett eget system, över alla verktyg och miljöer som ett team använder, oavsett om det är en agent eller en människa som styr.

Var ska man börja?

De flesta team har redan tester de litar på i Playwright, Cypress, k6, Postman eller det verktyg de har valt att standardisera på, och det är en utmärkt utgångspunkt. Här är några saker jag skulle föreslå:

  1. Kartlägg hur en ändring går från en prompt till produktion i dag och markera varje ställe där ett test körs. Om det bara finns ett enda test, nära slutet, skulle jag börja där.
  2. Var försiktig med att låta agenter i tysthet ändra befintliga tester. Forskarna bakom ImpossibleBench fann att begränsad åtkomst till tester minskade agenternas möjligheter att fuska. När en agent faktiskt behöver ändra ett test bör ändringen skickas in som en pull request som en person granskar, precis som annan kod.
  3. Kör testerna i testmiljöer (helst verkliga) i stället för i agenternas sandlådor, så tidigt som möjligt – även om det bara handlar om en liten svit grundläggande tester mot staging för varje ändring som genererats av en agent. Om du använder AI för att skriva tester bör du inte godkänna ett test förrän det har körts där.
  4. Samla testresultaten på ett ställe i ett kontrollplan – det kan vara ett rapporteringsverktyg, din APM-lösning eller en särskild testplattform. Se till att både människor och agenter har tillgång till resultaten.
  5. Mät leverans, inte aktivitet. Antalet pull requests säger väldigt lite. DORA:s leveransmått, till exempel ledtid för ändringar och felfrekvens för ändringar, säger mycket mer om huruvida AI hjälper.
  6. Låt agenter använda samma testinfrastruktur som dina medarbetare, så att deras arbete granskas enligt samma standard.

Optimistisk, men med förbehåll

Jag är optimist när det gäller AI och tror att den kommer att göra mjukvaruteam betydligt mer kapabla och i slutändan mer produktiva. Men för att nå dit måste teamen lita tillräckligt mycket på det agenterna producerar för att kunna leverera det. De behöver också ha en helhetssyn på testning i den agentbaserade SDLC:n – det är där förtroendet antingen byggs upp eller går förlorat.

Om du strävar efter en agentbaserad SDLC, vilken plats har testningen i den i dag?

Ole Lensmar är medgrundare och CTO på Testkube, den öppna testplattformen för AI-drivna ingenjörsteam. Han skapade SoapUI, ett av de mest använda verktygen för API-testning, och var tidigare ordförande för OpenAPI Initiative.