In het moderne tijdperk van computing is er een nieuw soort partner de werkplaats binnengekomen: het taalmodel. Dit zijn enorme, flexibele systemen die getraind zijn op gigantische bibliotheken van menselijke tekst, in staat om instructies te lezen en code te schrijven met een verbazingwekkende vloeiendheid. Voor velen voelt deze verschuiving als een plotselinge uitbreiding van capaciteit, waardoor beginners scripts kunnen bouwen en experts massale systemen kunnen aanpakken. Toch blijft er een fundamentele spanning bestaan. Hoewel deze machines taal kunnen verwerken, "leren" ze niet echt of onthouden ze wat er in een gesprek gebeurt zodra de sessie eindigt. Ze vertrouwen volledig op de tekst die op dat moment voor hen zichtbaar is, een beperkt venster van context dat constant moet worden bijgevuld met relevante details. Als een programmeur wil dat de machine de logica achter een stuk code begrijpt, moet die logica in de tekst direct naast de code aanwezig zijn. Dit creëert een uitdaging voor hoe we software schrijven. Traditioneel zijn code en de menselijke uitleg van die code in aparte plaatsen gehouden, of begraven in commentaren die machines vaak negeren. Maar als de machine een echte collaborateur moet zijn, moeten het verhaal van het programma en het programma zelf samen leven, zij aan zij, in een formaat dat zowel mensen als machines met gelijke gemak kunnen lezen.

Dit is het centrale probleem dat wordt aangepakt door een nieuwe omgeving genaamd notlob, gecreëerd door onderzoeker Adam T. Burke. Het werk stelt een terugkeer voor naar een oud idee dat bekend staat als literair programmeren, maar dan geüpdatet voor een tijdperk waarin zowel mensen als kunstmatige agenten dezelfde documenten lezen. In dit systeem is een softwareproject niet een verzameling afzonderlijke bestanden voor code, documentatie en tests. In plaats daarvan is het één enkel, vloeiend document dat lijkt op een essay. De tekst legt de ideeën, de motivatie en het ontwerp uit, terwijl de uitvoerbare instructies direct binnen de proza zijn ingebed. De onderzoekers hebben een werkend systeem gebouwd dat dit gecombineerde document behandelt als de primaire bron van waarheid. Wanneer het systeem het bestand leest, ziet het niet alleen woorden; het bouwt een gedetailleerde kaart van hoe elke naam, concept en stuk code met de anderen relateert. Deze kaart, die de auteur een naam-grafiek noemt, stelt een machine-agent in staat om het project te navigeren, niet door te zoeken naar trefwoorden, maar door de logische verbindingen tussen ideeën te volgen, net zoals een menselijke lezer een draad van gedachten door een boek zou volgen.

Het ontwerp van notlob wordt gedreven door drie eenvoudige observaties over hoe programmeren verandert. Ten eerste is natuurlijke taal de dominante manier geworden om software te specificeren en te organiseren bij het werken met kunstmatige intelligentie. Ten tweede zijn de door de computer gegenereerde controles die verifiëren of code nog werkt waardevoller dan ooit, dienend als een betrouwbare feedbackloop voor de agenten. Ten derde is de huidige generatie van deze taalmodellen zwaar afhankelijk van de hoeveelheid tekst die ze tegelijkertijd kunnen zien. Om dit aan te pakken, hebben de onderzoekers een taal gecreëerd waarin de uitleg, de uitvoering en de verificatie allemaal in hetzelfde bestand zitten. Een typisch document begint met een titel en een introductie, gevolgd door de kernlogica van het programma. Dit wordt gevolgd door een sectie voor tests en referenties, gescheiden door een eenvoudige lijn. Het systeem gebruikt specifieke markeringen om onderscheid te maken tussen een stuk proza, een codeblok, een eigenschap die altijd waar moet zijn, en een specifieke testcase. Bijvoorbeeld, een sectie kan een wiskundige sequentie beschrijven, gevolgd door de code die deze genereert, en dan een blok tekst dat stelt dat de code aan bepaalde regels moet voldoen. Het systeem voert vervolgens deze regels uit om te controleren of de code zich gedraagt zoals de tekst beweert dat hij zou moeten doen.

Om dit werkend te maken, hebben de onderzoekers een parser ontwikkeld die namen behandelt als de belangrijkste objecten in het systeem. In traditioneel programmeren is een naam slechts een label voor een variabele of functie. In notlob is een naam een "first-class citizen" die de geschreven uitleg verbindt met de uitvoerbare code. Wanneer het systeem een bestand verwerkt, construeert het een graaf die de tekst die een concept beschrijft verbindt met de code die het implementeert, en met de tests die het verifiëren. Deze structuur stelt een machine-agent in staat om van een hoog niveau van een idee te springen naar de specifieke regels code die het realiseren, of om elke plek te vinden waar een specifiek concept wordt gebruikt, zonder te verdwalen in een zee van bestanden. Het systeem bevat tools die deze kaart kunnen exporteren in standaardformaten, waardoor andere software de relaties tussen verschillende delen van het project kan bevragen. Dit bootst de manier na waarop een menselijke programmeur een geïntegreerde ontwikkelomgeving gebruikt om te vinden waar een functie is gedefinieerd of wie deze aanroept, maar doet dit door de semantische betekenis van de tekst te begrijpen, niet alleen de bestandsstructuur.

De onderzoekers testten deze omgeving door verschillende werkende programma's te bouwen, waaronder een hulpmiddel voor het converteren van getallen naar Romeinse cijfers en een webgebaseerd spel gebaseerd op Petri-netten, die diagrammen zijn die worden gebruikt om systemen met interagerende onderdelen te modelleren. In één experiment gebruikten ze een kunstmatige agent om te helpen een project vanaf nul te schrijven. De agent kreeg een hoog-niveau beschrijving van het doel en een paar lege functiesignaturen. De agent vulde vervolgens de code in, schreef de tests en organiseerde de proza, terwijl hij zich hield aan de structuur van het notlob-document. De agent was in staat om inconsistenties tussen de tekst en de code te detecteren, zoals een mismatch in de definitie van een functie, en vroeg om verduidelijking. In een ander geval hielp het systeem een agent om een subtiele bug te vinden in een digitaal signaalverwerkingsproject die door andere testmethoden was gemist. De bug was gerelateerd aan een berekening die instabiel werd onder bepaalde omstandigheden, en de property-tests van de agent, die als onderdeel van het essay waren geschreven, legden de fout succesvol bloot.

De onderzoekers observeerden echter ook dat de agenten niet perfect waren. In verschillende gevallen hadden de agenten de neiging om de declaratieve delen van het document te verwaarlozen, zoals de formele eigenschappen en de structurele regels, waarbij ze zich concentreerden op de directe taak van het schrijven van code. Ze behandelden de tekst soms als een suggestie in plaats van een beperking, wat leidde tot inconsistenties die menselijke interventie vereisten om op te lossen. De onderzoekers merkten op dat deze dynamiek bekend is bij menselijke softwareteams, waar senior developers vaak moeten ingrijpen om ervoor te zorgen dat de documentatie en de code op één lijn blijven. De studie suggereert dat hoewel deze taalmodellen krachtig zijn, ze nog steeds baat hebben bij een structuur die de code en de uitleg in nauw contact houdt. De notlob-omgeving biedt die structuur, een manier om de theorie van het programma en de praktijk van de code op dezelfde plek te houden.

Het werk onderscheidt zich ook van andere benaderingen voor het gebruik van taalmodellen in programmeren. Sommige methoden behandelen de natuurlijke taalbeschrijving als een aparte specificatie die voorafgaat aan het schrijven van de code, een proces dat kan leiden tot een disconnect tussen het plan en het resultaat. Anderen vertrouwen op het model om code te samenvatten of te regenereren nadat deze is geschreven. Notlob kiest een ander pad door de specificatie, de code en de tests samen te plaatsen in één enkele, iteratieve werkruimte. Dit stelt mensen en machines in staat om aan alle drie de elementen tegelijk te werken, waarbij de logica en de uitleg in tandem worden verfijnd. De onderzoekers argumenteren dat deze aanpak effectiever is dan het behandelen van de natuurlijke taal als een loutere prompt of een apart document. Door de proza en de code onscheidbare delen van hetzelfde artefact te maken, zorgt het systeem ervoor dat het contextvenster van het taalmodel gevuld is met de meest relevante informatie mogelijk.

De implementatie van notlob is een open-source project dat momenteel drie gevestigde programmeertalen ondersteunt: Haskell, Python en TypeScript. Het systeem bevat een reeks command-line tools waarmee gebruikers het project kunnen bouwen, testen en visualiseren. Eén tool kan het document renderen als een standaard webpagina, terwijl een andere een visuele kaart van de naam-graaf kan genereren, die laat zien hoe de verschillende delen van het project met elkaar verbonden zijn. De onderzoekers experimenteerden ook met het gebruik van het systeem om een "critic" agent te creëren, een kunstmatige intelligentie die de taken heeft om projecten te beoordelen op logische consistentie en stijl. Deze agent was in staat om fouten te identificeren en verbeteringen voor te stellen, waarbij hij soms verschillende persona's aannam om diverse perspectieven op het werk te bieden. Deze experimenten suggereren dat de omgeving niet alleen de creatie van code kan ondersteunen, maar ook de kritische beoordeling en verfijning van het gehele project.

Uiteindelijk presenteert het artikel een visie op een toekomst waarin softwareontwikkeling een collaboratieve daad is tussen mensen en machines, geworteld in een gedeelde taal van tekst en code. De notlob-omgeving claimt niet alle problemen van kunstmatige intelligentie in programmeren op te lossen, noch belooft het dat machines binnenkort zelfstandig perfecte software zullen schrijven. In plaats daarvan biedt het een praktisch hulpmiddel dat de relatie tussen het idee en de implementatie transparanter en robuuster maakt. Door het essay en de uitvoerbare code als één enkel, onderling verbonden entiteit te behandelen, hel help het systeem de kloof tussen menselijke intentie en machine-executie te overbruggen. Het werk suggereert dat de toekomst van programmeren misschien niet gaat over het schrijven van meer code, maar over het schrijven van betere verhalen die de code kan volgen, waardoor de logica van het systeem even helder is voor de machine als voor de mens.