Translatie: Waarom grote taalmodellen geen software kunnen bouwen Auteur: Conrad Irwin Een van de dingen waar ik veel tijd aan heb besteed, is het interviewen van software-engineers. Dit is duidelijk een zware taak, en ik durf niet te zeggen dat ik een geheim wapen heb; maar deze ervaring heeft me wel de tijd gegeven om na te denken over wat een efficiënte software-engineer eigenlijk doet. De kerncyclus van software-engineering Wanneer je naar een echte expert kijkt, zie je dat ze altijd de volgende stappen in een cyclus uitvoeren: * Een mentaal model opbouwen van de vereisten. * Code schrijven (hopelijk?!), die aan de vereisten voldoet. * Een mentaal model opbouwen van het werkelijke gedrag van de code. * De verschillen tussen beide identificeren en vervolgens de code (of vereisten) bijwerken. Er zijn veel manieren om deze stappen te voltooien, maar het bijzondere aan efficiënte engineers is dat ze in staat zijn om duidelijke mentale modellen op te bouwen en te onderhouden. Hoe presteren grote taalmodellen? Eerlijk gezegd zijn grote taalmodellen behoorlijk goed in het schrijven van code. Wanneer je het probleem aanwijst, doen ze het ook goed in het bijwerken van de code. Ze kunnen alles doen wat echte engineers doen: code lezen, tests schrijven en uitvoeren, logs toevoegen, en (waarschijnlijk) een debugger gebruiken. Maar wat ze niet kunnen, is het onderhouden van duidelijke mentale modellen. Grote taalmodellen raken verstrikt in eindeloze verwarring: ze veronderstellen dat de code die ze schrijven echt werkt; wanneer tests falen, kunnen ze alleen maar raden of ze de code of de tests moeten repareren; wanneer ze gefrustreerd zijn, gooien ze gewoon alles weg en beginnen opnieuw. Dit staat in schril contrast met de eigenschappen die ik van engineers verwacht. Software-engineers testen terwijl ze werken. Wanneer tests falen, kunnen ze hun mentale model gebruiken om te beslissen of ze de code of de tests moeten repareren, of meer informatie moeten verzamelen voordat ze een beslissing nemen. Wanneer ze gefrustreerd zijn, kunnen ze hulp zoeken door met anderen te communiceren. Hoewel ze soms ook alles weggooien en opnieuw beginnen, is dat een keuze die ze maken nadat ze een duidelijker begrip van het probleem hebben gekregen. Maar dat gaat snel, toch? Zal dit veranderen naarmate de modellen krachtiger worden? Misschien?? Maar ik denk dat dit een fundamentele verandering in de manier waarop modellen bouwen en optimaliseren vereist. Het model dat software-engineering nodig heeft, is niet alleen in staat om code te genereren. Wanneer een persoon een probleem tegenkomt, kan hij tijdelijk alle context opzijzetten, zich concentreren op het oplossen van het huidige probleem, en dan weer terugkeren naar de grotere vragen. Ze kunnen ook soepel schakelen tussen het grote geheel en de kleine details, tijdelijk de details negeren om zich op het geheel te concentreren, en indien nodig dieper in de details duiken. We worden niet efficiënter door simpelweg meer woorden in ons "contextvenster" te proppen; dat maakt ons alleen maar gek. Zelfs als we enorme hoeveelheden context kunnen verwerken, weten we dat de huidige generatieve modellen verschillende ernstige problemen hebben die hun vermogen om duidelijke mentale modellen te onderhouden, rechtstreeks beïnvloeden: * Contextverlies: modellen zijn niet goed in het ontdekken van genegeerde contextinformatie. * Recency bias: ze worden sterk beïnvloed door recency bias bij het verwerken van het contextvenster. * Hallucinaties: ze "hallucineren" vaak details die er niet zouden moeten zijn. Deze problemen zijn misschien niet onoverkomelijk, en onderzoekers werken eraan om modellen geheugen te geven, zodat ze soortgelijke denkvaardigheden als wij kunnen toepassen. Maar helaas, op dit moment kunnen ze (boven een bepaalde complexiteit) eigenlijk niet begrijpen wat er aan de hand is. Ze kunnen geen software bouwen omdat ze niet in staat zijn om twee vergelijkbare "mentale modellen" gelijktijdig te onderhouden, de verschillen te identificeren en te beslissen of ze de code of de vereisten moeten bijwerken. Wat nu te doen? Het is duidelijk dat grote taalmodellen nuttig zijn voor software-engineers. Ze kunnen snel code genereren en presteren goed in het integreren van vereisten en documentatie. Voor sommige taken is dat al voldoende: de vereisten zijn duidelijk genoeg, het probleem is eenvoudig genoeg, en ze kunnen het in één keer oplossen. Dat gezegd hebbende, voor elke taak met enige complexiteit kunnen ze niet nauwkeurig genoeg de benodigde context behouden om door iteratie uiteindelijk een werkbare oplossing te produceren. Jij, als software-engineer, moet nog steeds verantwoordelijk zijn voor het waarborgen van duidelijke vereisten en ervoor zorgen dat de code daadwerkelijk de beloofde functionaliteit levert. Bij Zed geloven we dat de toekomst van menselijke en AI-agenten samen software kan bouwen. Maar we zijn er sterk van overtuigd (tenzij in het huidige geval) dat jij de bestuurder bent die het stuur vasthoudt, terwijl grote taalmodellen slechts een ander hulpmiddel zijn dat binnen handbereik ligt.