AI

Vertrouwen komt eerst bij AI-codingagents

Meer agents vermenigvuldigen het controlewerk. Vertrouwen groeit als een draaiende app, geteste skills en een architectuur die foute wijzigingen afwijst op één lijn staan.

Vertrouwen komt eerst bij AI-codingagents

Meer AI-codingagents klinken als meer snelheid. In de praktijk vermenigvuldigen ze vaak iets anders: het werk van degene die moet controleren of de output klopt.

Dat is de kern van de workshop van Lauren Tan, software engineer, zoals die in oktober 2026 viraal ging en daarna is nagekeken door Superbash. De opname duurt 57 minuten. Superbash baseert de analyse op een volledige kijkbeurt, twee transcripten en de slides. De cijfers hieronder zijn haar claims uit die workshop, geen onafhankelijk gecontroleerde metingen.

Vertrouwen in agentwerk groeit als drie dingen op één lijn staan: een draaiende app die je kunt controleren, skills die een evaluatie overleven, en een architectuur die foute wijzigingen afwijst. Bewijs eerst één lokale workflow. Schaal daarna pas.

Wat de virale caption erbij verzon

De posts beloofden een kant-en-klaar autonoom bedrijf. Vijftig-plus GrokBot-agents die het werk van twintig engineers doen. Een chief of staff, drie AI-productmanagers en veertig workers die ’s nachts doorwerken. Een adoptie van 97 procent. Salarisaanbiedingen boven de 750.000 dollar.

Die claims staan niet in de workshop. Tan beschrijft een conceptuele trust curve en zegt dat er ’s nachts ongeveer twintig pull requests binnenkwamen. Pull requests zijn geen engineers. Ze zegt dat ze wakker werd met gelande PR’s en die op main bekeek. De koffiescène, de hiërarchie en de salariscijfers horen bij de caption, niet bij de talk.

Dat onderscheid doet ertoe. Wie het organogram nabouwt, mist het eigenlijke ingenieurswerk: agents bewijs geven, hun procedures toetsen, en hun wijzigingen begrenzen.

De trust curve

Bij laag vertrouwen micromanage je een agent. Je kijkt elke output na, controleert het werk en levert de correcties. Elke extra agent vergroot die toezichtslast. Betrouwbaarheid moet eerst omhoog voordat autonomie nuttig wordt. Een hogere agenttelling veroorzaakt die betrouwbaarheid niet vanzelf.

De curve is een schets van die voortgang. Geen meetwet, en geen bewijs dat iemand duizenden agents tegelijk draait. De agent-aantallen op de slide zijn illustratieve stadia.

Ook de productiecijfers vragen diezelfde voorzichtigheid. Op de slide staan meer dan 3.000 pull requests in vijf maanden. Tan zegt dat ze de maand ervoor ongeveer 1.000 heeft verscheept, dat er zo’n 20 PR’s per nacht landden, en dat de architectuurrefactor van GrokBot meer dan 600 PR’s kostte. Die getallen overlappen. Optellen mag niet. Een PR meet ook geen vervanging van een engineer en geen codekwaliteit. Een kleine verwijdering en een flinke feature tellen allebei als één. Tan pleit voor atomaire wijzigingen, zodat de geschiedenis bruikbaar blijft en een regressie terug te draaien is.

De vraag die je mee kunt nemen: welk bewijs maakt elke wijziging reviewbaar?

Eerst een draaiende app

Tans verhaal over een trage app in launch week laat zien waarom zelfvertrouwen van een agent tekortschiet. Ze verzamelde traces, interpreteerde ze en gaf het bewijs terug aan een agent die zelfverzekerd naar oorzaken gokte. De mens bleef de feedbacklus. In haar woorden: jij bent de verifier. Extra workers laten dat knelpunt staan.

Haar skill control-glass stuurt een development-build aan via Chrome DevTools Protocol, getoond als Control Glass met Playwright. Op het scherm: DOM- en accessibility-inspectie, klikken, typen, screenshots, CPU-traces, heap-snapshots, console en netwerk, en sessies die per worktree geïsoleerd zijn. Dat zijn getoonde mogelijkheden, geen publiek installatierecept.

Een draaiende app laat de agent verwacht gedrag vergelijken met wat er gebeurt. Een plausibele patch is iets anders dan een werkende gebruikersflow. Dat bewijs zegt nog niets over onderhoudbaarheid. Een feature kan werken en tegelijk een dure dependency of een tweede eigenaar van dezelfde staat introduceren.

Daar hoort een feature map bij. Een screenshot van een sidebar noemt geen bronbestand. Een map koppelt UI-namen, randvoorwaarden, routes, stabiele selectors, shortcuts en eigenaarschap in de code, zodat de agent de juiste flow bereikt vóórdat hij code wijzigt. Tan beschrijft bij pstack skills om die context te bouwen en bij te houden. De map hoort naast de UI te leven en mee te veranderen. Een verouderde selector is een reden om te onderzoeken, in plaats van een oordeel te gokken.

Een verificatie die je kunt vertrouwen eindigt met PASS, FAIL of BLOCKED, plus verwacht versus gezien gedrag en paden naar screenshots en logs. Ontbrekende testdata, een selector of een tool is BLOCKED. Nooit PASS. Succes afleiden uit “de build is groen” of uit het voltooiingsbericht van de agent telt niet.

Evalueer de skill voordat je het oordeel gelooft

“Evals zijn in feite een manier om je skills te unit-testen,” zegt Tan. pstack groeide uit waargenomen fouten: gokken naar oorzaken, relevante code niet lezen, succes melden zonder bewijs. Die fouten omzetten in instructies is stap één. Stap twee is kijken of de instructie het gedrag verandert.

In haar aanpak definieert een coördinator een rubric. Subagents draaien geïsoleerde cases. Een judge op een ander model kruist de resultaten. Neutrale mapnamen zijn een truc om evaluatie-cues te verminderen. Ze bewijzen niet dat een model de test niet herkent. Testen over modellen heen laat zien of een skill meereist voorbij de worker waarvoor hij is geschreven.

Ze gebruikt /loop om naar een 10/10 te blijven itereren. Die score verdient scepsis. Een judge kan dezelfde fouten maken als de worker, en een perfecte score kan een te makkelijke rubric zijn. Bewaar het bewijs waarmee iemand de score kan aanvechten.

Een bruikbare evaluatie, als aanpassing van die aanpak en niet als haar configuratie, ziet er zo uit:

  • Bevries een kapotte fixture, een werkende fixture, en een derde zonder testdata waarvan het juiste oordeel BLOCKED is.
  • Houd antwoordkeys en een onaangeroerde holdout buiten het bereik van de workers.
  • Geef elke worker dezelfde opdracht, in een eigen checkout en een eigen browsersessie.
  • Scoor deterministisch op verwacht oordeel, zichtbare rijen en build-id. Laat een ander model alleen de artefacten tegen de bevroren rubric leggen.
  • Faalt een case, herschrijf dan alleen de skill, op basis van de geziene fout. Laat de antwoordkey met rust.
  • Zet een plafond op rondes, gelijktijdige workers en tijd. Stop als een plafond raakt, en rapporteer wat er open bleef.
  • Draai de holdout één keer, met de skill bevroren. Faalt die, ontwerp dan een nieuwe evaluatie voordat je opnieuw probeert.

Een 10/10 op deze cases is een resultaat op deze cases. Geen productcertificaat. Verzonnen bewijs, een check op de verkeerde build, of een wijziging buiten scope is een harde fout, ongeacht het totaal.

Maak het ondersteunde pad het korte pad

Dune is Tans codenaam voor de architectuur van GrokBot: conventies en principes, geen publiek pakket dat je kunt installeren. Haar zorg is dat shortcuts uit een prototype samenklonteren tot gedeelde complexiteit. Elke latere wijziging wordt dan moeilijker te beoordelen. Bestaande code met sterke conventies heeft gerichte verbetering nodig. Greenfield-werk heeft de beperkingen vroeg nodig.

Vijf principes op haar slide wijzen dezelfde kant op. De ondersteunde route moet minder beslissingen vragen dan een shortcut. Verboden dependencies moeten automatisch falen. Elke duurzame waarde heeft één eigenaar die hem schrijft. Nieuwe features voegen geïsoleerde bestanden toe, in plaats van extra takken in gedeelde wortels. Uitzonderingen zijn klein, expliciet, en onder review.

Een feature-map naast de code geeft agents een plek om te werken, met herkenbare ingangen. De scheiding tussen main en renderer in Electron houdt zwaar werk van de renderer af en beschermt het framebudget van ongeveer 16 milliseconden. In haar formulering: het kortste pad is het beste pad.

Daarbovenop liggen vijf lagen, van zacht naar hard: stijlgids, skills, rules en Bugbot, statische analyse (lint, compiler, CI), en de architectuur van de codebase zelf. Zachte instructies vergeet een model. Een mechanische fout dwingt een wijziging in code of configuratie af. Architectuur en een compiler maken bugs niet onmogelijk. Ze maken de bekende, herhaalde fout duur.

Tan stelt de praktische vraag hardop: hoe maak ik van deze reviewopmerking een lintregel, en hoe maak ik er een CI-failure van? Haar verbod op useEffect en op codecommentaar zijn keuzes voor dát project. Agents schreven daar irrelevante historische uitleg in comments. De overdraagbare stap is smaller. Zoek één fout die steeds terugkomt, en codeer een check met een duidelijk ondersteund alternatief in de foutmelding.

Lokaal bewijzen, daarna pas de cloud

“De beste plek om te beginnen is lokaal, want daar kun je kijken.” Zolang je tool-aanroepen en app-gedrag kunt zien, kun je de skill corrigeren. Opent de agent de verkeerde build, mist hij een randvoorwaarde, of houdt hij een laadstatus voor succes, dan zie je dat vóór je het ergens anders automatiseert.

Pas als die lus stabiel is, hergebruik je dezelfde omgeving en dezelfde skill in de cloud. In het voorbeeld Benny pakt bugreports op, start een eigen cloud-desktop, stuurt Cursor aan met dezelfde control-skills en probeert het gedrag te reproduceren. Het nuttige resultaat was dat een melding reproduceerde op een oudere build, terwijl het op main al gefixt was. De resterende actie was een nieuwe build uitbrengen. Benny hoefde geen tweede fix te schrijven.

Build- en omgevingsidentiteit horen bij het bewijs: gemelde versie, geteste commit, staat van de fixture, exacte stappen, naast screenshots of een opname. Onderscheid gereproduceerd, niet gereproduceerd, al gefixt, en geblokkeerd. Een melding zonder reproduceerbare omgeving blijft geblokkeerd tot de ontbrekende informatie er is.

Tan beschrijft ook dat productmanagers, designers en go-to-market-collega’s meedoen binnen het begrensde systeem. Dat zijn menselijke collega’s. In het PM-voorbeeld beschrijft ze nog steeds dat zij de voorgestelde fix reviewt. De winst is dat bijdragers het ondersteunde pad volgen en bewijs terugbrengen. Het voltooiingsbericht van een agent haalt die verantwoordelijkheid niet weg.

Wat je deze week kunt doen

Tan werkt bij een AI-lab en zegt dat ze daar onbeperkte tokens heeft. Direct daarna waarschuwt ze om haar aanpak niet één op één over te nemen. De investering vooraf is groot, en de afweging van opbrengst tegen kosten is per team anders.

Voor een eerste week is één agent en één flow genoeg.

  1. Schrijf één map-entry voor één gebruikersflow.
  2. Verzamel één bewijsbundel: scherm, console, commit, exacte stappen.
  3. Controleer dat je een werkende run van een kapotte kunt onderscheiden.
  4. Voeg een kapotte fixture, een werkende fixture en een holdout zonder data toe. Die laatste moet BLOCKED teruggeven.
  5. Zet één terugkerende reviewfout om in een verplichte check.
  6. Verplaats alleen de stabiele reproductietaak naar de cloud, nadat die betrouwbaar bewijs teruggeeft.

Zet retries en gelijktijdige workers expliciet in een budget. Stop als tijd of geld op is, en noteer open werk eerlijk. Meet kosten per geverifieerde taak, reviewtijd en regressies naast het aantal PR’s. Een goedkope voltooiing die een lang handmatig onderzoek uitlokt is een slechter resultaat. Een BLOCKED dat een valse fix voorkomt kan waardevol zijn.

Waar vertrouwen uit bestaat

Vertrouwen in codingagents is een keten die een reviewer kan nalopen. De app deed wat de feature map beloofde. De skill haalde dat oordeel ook op een onaangeroerde case. De architectuur wees de bekende shortcut af voordat een mens ernaar hoefde te kijken.

Die keten begint klein, op één machine, bij één flow die je zelf kunt zien falen. Autonomie is wat er overblijft als die controle saai is geworden.

Bron: Lauren Tan’s AI Coding Agents Workflow: Trust Comes First, Superbash, 28 oktober 2026. De analyse daar steunt op de workshopopname, niet op een audit van de genoemde PR-totalen.

← Terug naar Blog

Gerelateerde Artikelen