Deze keer gebeurde de ontwikkeling van menselijke software "in omgekeerde richting"! Zojuist onthulde OpenAI's officiële blog een van hun interne experimenten: een eerste team van drie ingenieurs gebruikte de Codex-agent om in vijf maanden tijd een "miljoen-regelig codeproduct" helemaal opnieuw te maken. Gedurende het hele proces schrijven mensen geen handmatige code, maar concentreren ze zich op "helder nadenken over wat ze willen en het vaststellen van regels", en laten ze al het andere over aan AI.

Elke persoon kan elke dag gemiddeld 3,5 PR's (Pull Requests, verzoeken om code samen te voegen) pushen, en het volledige PR-uitvoeringsproces (implementatie, testen, documentatie, CI-configuratie) wordt afgehandeld door agenten.

OpenAI gaf deze workflow een zeer levendige naam: "Harness Engineering".


https://openai.com/index/harness-engineering/

In het experiment zijn programmeurs niet langer de 'codeerders' die laat opblijven om bugs te schrijven en vervolgens laat opblijven om bugs te repareren, maar worden de oorspronkelijke 'uitvoerders' 'chauffeurs'.

Dit is niet alleen een ‘productiviteitsrevolutie’ met een tienvoudige toename van de efficiëntie, maar een ondermijning van de definitie van ‘software-engineering’ en luidt direct het einde in van het ‘tijdperk van handmatige codering’ van de mensheid.

Wijziging

Begin met een lege git-repository

Dit experiment begon met de eerste inzending van AI.

Eind augustus 2025, toen de eerste commit in het lege magazijn viel, was deze niet langer door mensen geschreven - er was geen bestaande menselijke code die als "anker" kon dienen.

Nog magischer: zelfs de eerste versie van de handleiding AGENTS.md die werd gebruikt om AI te begeleiden hoe te werken, was door AI zelf geschreven.

Vanaf dag één is dit magazijn vormgegeven door agenten.Mensen mogen geen code schrijven, wat een onoverkomelijke ijzeren regel is geworden voor dit project.

Dit is niet voor luiheid, maar voor een soort ‘opzettelijke praktijk’ die bijna masochistisch is. Alleen door de ontsnappingsroute voor mensen af ​​te snijden om ‘aan de slag te gaan’ kan het team gedwongen worden om het ultieme probleem van het bouwen van code zonder iemand op te lossen.

Als gevolg hiervan leek dit kleine team van 3 personen (later uitgebreid tot 7 personen) plotseling een herder die een zweep vasthield en een groep onvermoeibare Codex-agenten aandreef om wild over het codegrasland te rennen.

De resultaten zijn verbluffend:5 maanden, 1 miljoen regels code.

Herdefinitie van de rol van de ingenieur

De eerste voortgang van het experiment verliep langzamer dan de onderzoekers van OpenAI hadden verwacht.

Het is niet zo dat Codex niet werkt, maar dat de omgeving niet duidelijk genoeg gedefinieerd is: de agent mist de tools, abstracties en interne structuren die nodig zijn om doelen op hoog niveau te bereiken.

Als gevolg hiervan werd de hoofdtaak van het OpenAI-engineeringteam één ding:Geef de agent de mogelijkheid om waardevol werk te voltooien.

Ze verdelen grote doelen in kleinere bouwstenen (ontwerp, code, beoordeling, testen, enz.), vragen de agent om deze blokken samen te voegen en gebruiken ze vervolgens om complexere taken te ontgrendelen.

Als dingen mislukken, is het antwoord bijna nooit 'probeer het opnieuw'. De enige manier om verder te komen is door Codex het werk te laten doen. Menselijke ingenieurs doen meestal een stapje terug en vragen zich af:

Welk vermogen ontbreekt? Hoe kan het zowel zichtbaar voor de agent als afdwingbaar worden gemaakt?

Gedurende het hele proces hebben mensen vrijwel uitsluitend via prompte woorden interactie met het systeem: de ingenieur beschrijft de taak, geeft leiding aan de agent en laat hem een ​​PR initiëren.

Om de PR te bevorderen, zullen onderzoekers Codex zelf de wijzigingen lokaal laten beoordelen, aanvullende beoordelingen van lokale en cloudagenten aanvragen, reageren op feedback van mensen of agenten, en vervolgens in een lus herhalen totdat alle agentreviewers tevreden zijn.

In de loop van de tijd werd bijna al het recensiewerk verplaatst naar "agent versus agent".

Verbeter de leesbaarheid van applicaties

Naarmate de codedoorvoer toenam, ontdekte OpenAI:Het knelpunt van AI-codering wordt het vermogen van handmatige kwaliteitscontrole (QA).

Menselijke tijd en aandacht worden zo echte beperkingen.

Om dit knelpunt te doorbreken, is de aanpak van OpenAI om Codex in staat te stellen direct de gebruikersinterface, logs, applicatie-indicatoren, enz. van de applicatie te lezen.

Ze integreerden het Chrome DevTools-protocol in de agentruntime en ontwikkelden vaardigheden voor het verwerken van DOM-snapshots, schermafbeeldingen en navigatie.


Als gevolg hiervan kan Codex zelf bugs reproduceren, reparaties verifiëren en redeneren over het gedrag van de gebruikersinterface.

OpenAI hanteert dezelfde aanpak met observatietools.

Logboeken, statistieken en sporen worden aan Codex blootgesteld via een lokale observatiestapel en vormen geïsoleerde, tijdelijke omgevingen voor elke werkboom (werkruimte).

Nadat de taak is voltooid, wordt de omgeving vernietigd.

Agenten kunnen LogQ gebruiken om logboeken te controleren en PromQL om indicatoren te controleren.

Als gevolg hiervan worden prompts zoals "Zorg ervoor dat het opstarten van de service binnen 800 ms is voltooid" of "Geen enkele periode tussen de vier key user-paden groter dan twee seconden" echt uitvoerbaar.

Nadat ze dit hebben gedaan, zien OpenAI-onderzoekers vaakCodex werkt continu meer dan zes uur achter elkaar, meestal terwijl mensen slapen.

Geef Codex een kaart

In plaats van een handleiding van 1000 pagina's

Contextbeheer is een van de grootste uitdagingen als u agenten grote en complexe taken laat uitvoeren.

Een eenvoudige les die OpenAI-onderzoekers al vroeg leerden, is deze:

Geef Codex een kaart, geen handleiding van 1000 pagina's.

In het begin probeerde het team een ​​heel groot AGENTS.md-bestand te schrijven en daarin alle regels, logica en voorzorgsmaatregelen te stoppen. Het bleek een ramp.

Omdat de aandacht van AI ook een schaars goed is.

Geef het een handleiding van 1000 pagina's en het zal verdwalen in details, belangrijke beperkingen over het hoofd zien of de doelstellingen verkeerd formuleren.

Bovendien is het bijhouden van zo'n groot document een nachtmerrie en zal het spoedig een 'kerkhof van oude regels' worden.

Als gevolg hiervan paste het team snel hun strategie aan en veranderde AGENTS.md in een 'schatkaart'.

Dit bestand is slechts ongeveer 100 regels lang en bevat geen specifieke kennis, alleen een inhoudsopgave, zoals een navigatiekaart die verwijst naar diepere bronnen van waarheid diep in het magazijn.

Ontwerpdocumenten worden gecatalogiseerd en geïndexeerd, inclusief de validatiestatus en een reeks kernovertuigingen die de 'agent-first'-werkingsprincipes definiëren.

De echte kennisbank bevindt zich in de gestructureerde docs/directory en is de enige bron van waarheid van het systeem.

Dit is ‘progressieve openbaarmaking’: de agent begint met een kleine en stabiele ingang en wordt geleerd waar hij vervolgens moet kijken, in plaats van vanaf het begin overweldigd te worden door informatie.

OpenAI-onderzoekers hebben ook tools om dit af te dwingen.

Controleer of de kennisbank up-to-date en onderling verbonden is en een correcte structuur heeft via gespecialiseerde lint- en CI-taken.

Architectuurdocumenten geven een overzicht op het hoogste niveau van domeinpartitionering en pakketlagen. Kwaliteitsdocumentatie beoordeelt elk productgebied en elke architectuurlaag en spoort voortdurend hiaten op.

Om ervoor te zorgen dat de AI geen verouderde informatie leest, heeft het team zelfs speciaal een ‘document gardener’-agent geregeld.

Het heeft maar één taak: documenten regelmatig scannen, verouderde beschrijvingen vinden die inconsistent zijn met de code-implementatie, en vervolgens automatisch een reparatie-PR initiëren.

Laat de intelligente agent ‘begrijpen’

Omdat het magazijn volledig door de agent wordt gegenereerd, is een van de doelen van OpenAI-onderzoekers om de agent het volledige bedrijfsdomein te laten begrijpen, alleen door te vertrouwen op het magazijn zelf.

Vanuit het perspectief van een agent bestaat er geen kennis waartoe hij geen toegang heeft in de runtimecontext.

Kennis die in Google Documenten wordt geplaatst, chatrecords en menselijke hersenen zijn bijvoorbeeld allemaal onzichtbaar voor het systeem.

Het enige dat het kan zien zijn versiegerelateerde artefacten in het magazijn, zoals code, Markdown, schema en uitvoerbare plannen.

Als agenten deze contextuele kennis niet kunnen vinden, zullen ze net zo onwetend zijn als hun nieuwe collega's op het werk en geen idee hebben wat er werkelijk aan de hand is in het bedrijf.


Daarom moet steeds meer context terug naar het magazijn worden geduwd.

Het geven van meer context aan de Codex betekent uiteraard niet dat er meer verspreide instructies aan worden gegeven, maar dat de informatie zo wordt georganiseerd en gestructureerd dat deze kan worden beredeneerd.

Geautomatiseerd hek

Laat programmeurs de ‘herders’ van de codewereld worden

Documentatie alleen is niet voldoende om een ​​volledig door agenten gegenereerde codebasis consistent te maken.

AI is immers een probabilistisch model. Het kan hallucineren, lui zijn en code schrijven die 'lijkt te werken, maar in werkelijkheid een puinhoop is'.

Hoe het op te lossen?

Agents werken het beste in omgevingen met duidelijke grenzen en voorspelbare structuren.

Door 'invarianten' af te dwingen in plaats van implementatiedetails op microniveau te beheren, stelt OpenAI agenten in staat om met hoge snelheid vooruit te gaan zonder de basis te breken.

Dit is hetzelfde als het aandoen van de teugels en het zadel van een KI-paard als Codex, dat elke dag duizenden kilometers aflegt.

OpenAI bouwt systemen rond een rigoureus architectonisch model. Elk bedrijfsgebied heeft een vaste hiërarchie en de afhankelijkheidsrichtingen worden strikt gecontroleerd, waardoor slechts beperkte wettelijke grenzen mogelijk zijn.

De regel is simpel: binnen elk bedrijfsgebied (zoals app-instellingen) kan code alleen afhankelijk zijn van 'vooruit' volgens een vaste hiërarchie:

Typen → Configuratie → Repo → Service → Runtime → UI

Transversale zaken (authenticatie, connectoren, telemetrie, functieschakelaars, enz.) zijn alleen beschikbaar via één expliciete interface: Providers.

Andere afhankelijkheden zijn verboden en worden afgedwongen via aangepaste linten (ook gegenereerd door Codex) en structurele tests.


Dit soort architectuur wordt doorgaans alleen zorgvuldig ontworpen als de bedrijfsschaal honderden mensen bereikt.Maar in het geval van codeermiddelen is dit een vereiste.

Bovendien definieerden OpenAI-onderzoekers een reeks ‘smaakinvarianten’, zoals:

Gestructureerde logboekregistratie afdwingen

Schema- en typenaamgevingsconventies

Maximale bestandsgrootte

Betrouwbaarheidsvereisten op platformniveau

In dit proces moet een duidelijk onderscheid worden gemaakt tussen waar striktheid vereist is en waar autoriteit kan worden gedelegeerd.

Dit is als het beheren van een groot ingenieursplatform: gecentraliseerde controle aan de grenzen en een hoge mate van interne autonomie.

De door AI gegenereerde code voldoet misschien niet aan de menselijke esthetiek, maar zolang deze correct, onderhoudbaar en leesbaar is voor de intelligente agent, is het oké.

In dit proces zal de menselijke smaak niet verdwijnen, maar zal deze in het systeem blijven ‘gecodeerd’.

Recensiecommentaar, refactoring PR's en gebruikersbugs worden omgezet in documentupdates of direct geüpgraded naar toolregels.

Wanneer documentatie niet voldoende is, moeten regels in code worden geschreven.

Gooi het toetsenbord weg

Wees moedig om AI te beheersen

Dit experiment van OpenAI kondigde aan:Een groot aantal op CRUD gebaseerde banen wordt hervormd.

Als een systeem dat helemaal opnieuw is begonnen, binnen vijf maanden door drie mensen kan worden gebouwd op een schaal van één miljoen regels (zonder een regel code te schrijven), is het dan nog steeds nodig dat de enorme ontwikkelingsteams in traditionele softwarebedrijven bestaan?

In dit komende nieuwe tijdperk zal de definitie van een ingenieur volledig herschreven worden.

Wat je nodig hebt zijn sterke ‘architectonische capaciteiten’ om de grenzen van het systeem te kunnen definiëren, beperkingen tussen modules te kunnen ontwerpen en het ‘hek’ te kunnen bouwen dat ervoor zorgt dat AI niet op een dwaalspoor terechtkomt.

Tegelijkertijd heb je ook nauwkeurige ‘expressievaardigheden’ nodig en leer je je bedoelingen in de duidelijkste taal aan AI te beschrijven (of het nu gaat om natuurlijke taal of gestructureerde documenten).

Degenen die AI-programmering weigeren en erop aandringen om met de hand te coderen, zullen uiteindelijk door de golf worden opgeslokt. Alleen programmeurs die weten hoe ze AI moeten controleren, zullen waarschijnlijk winnaars worden in het AI-tijdperk.