Elke AI-functie heeft ergens een definitie van goede output. Soms staat die op papier. Vaker zit die in het hoofd van degene die de evaluatie heeft opgezet, en dat is meestal een engineer, onder tijdsdruk, die controleert op de dingen die het makkelijkst te controleren zijn. Die definitie schrijven is designwerk, en designers zouden er eigenaar van moeten zijn.
Een eval, kort voor evaluatie, is een herhaalbare test van wat een AI-functie produceert: een set invoer en een set criteria. De functie draait op de invoer, de output wordt langs de criteria gelegd, en het geheel draait opnieuw elke keer dat de instructies die de functie krijgt (de prompt), het model of de data veranderen. De machinerie die het draaien doet, is engineering. De criteria zijn oordeel: een lijst van wat deze functie moet doen, nooit mag doen, en slecht mag doen.
Itamar Medeiros maakt dezelfde verdeling in een stuk over evals voor designers en productmanagers (opent in een nieuw tabblad): engineers bouwen en draaien de machinerie, maar de inbreng die het betekenis geeft, is inbreng van design en product, en als engineers de criteria alleen bepalen, schuift de eval op naar wat makkelijk te meten is. Zijn zin voor een eval zonder dat werk is een goede: "An eval without good criteria is a ruler with no units." Oftewel: een eval zonder goede criteria is een liniaal zonder eenheden.
Hetzelfde oordeel als bij een design review
In een design review kijk ik naar een scherm en zeg ik bijvoorbeeld: deze melding over een geweigerde betaling vertelt de persoon niet of er geld is afgeschreven. Die zin is een criterium. Hij wordt één keer gezegd, over één scherm, tegen de mensen in de ruimte, en bij de volgende release is hij weg, tenzij iemand hem onthoudt.
Een eval is die zin opgeschreven, zodat hij geldt voor elke output die de functie ooit zal produceren. Aan het oordeel verandert niets. Wat verandert, is dat het niet meer afhangt van wie er in de ruimte zat, en dat het niet meer verloopt.
Daarom accepteer ik niet dat evals worden neergezet als een testkwestie die design overdraagt aan engineering. Een team dat iemand anders de criteria laat schrijven, laat iemand anders de design review doen, voorgoed, bij elke output, zonder dat er een designer bij is. De oordeelslaag verdwijnt niet omdat de output gegenereerd is. Die moet alleen worden opgeschreven, anders gebeurt het helemaal niet.
Bij betalingen worden de criteria concreet
Betalingen zijn een goede plek om dit te leren, omdat "goed genoeg" daar een prijs heeft. Een verkeerd bedrag is een verkeerd bedrag. Een afschrijving die mislukte en leest alsof hij gelukt is, wordt een supportticket, dan een terugbetaling, dan een klant die niet terugkomt. Een melding over een geweigerde betaling die iemand in het ongewisse laat of er geld is verplaatst, is geen toonprobleem, het is het hele probleem. Elke status waarin een betaalflow kan zitten, van in behandeling tot geweigerd, is een plek waar een gegenereerd antwoord vol overtuiging fout kan zijn.
Die druk is nuttig, omdat vage criteria er onmogelijk te verdedigen zijn. Stel je een assistent voor die antwoord geeft op de vraag "waarom is er twee keer geld afgeschreven?" Een criterium als "het antwoord is behulpzaam en klopt" controleert niets. Deze controleren wel iets:
- Het noemt nooit een bedrag dat niet in de transactiegegevens staat die het heeft gekregen.
- Het houdt geld dat de bank alleen heeft gereserveerd uit elkaar met geld dat echt is afgeschreven, en zegt welke van de twee dit is.
- Het zegt wat er hierna gebeurt en wanneer, of zegt eerlijk dat het dat niet weet.
- Het belooft nooit een terugbetaling, omdat het die niet kan uitvoeren.
Elk daarvan is iets wat een controleur, een mens of een programma, bij één output als goed of fout kan markeren. Dat is de toets of een regel in een eval thuishoort.
Wat een eval bevat die een designer heeft geschreven
Paren van goede en slechte output
Geen definitie van goed, want die kan niemand consequent toepassen, maar voorbeelden: dit antwoord is goed, dit is fout, en dit is de zin die het verschil uitlegt. De slechte voorbeelden zijn belangrijker dan de goede, omdat ze de grens markeren. Een goed antwoord laat zien waar je op hoopte. Een slecht antwoord dat er bijna goed uitziet, laat zien waar de grens ligt.
De situaties
Dezelfde lijst die een designer al bijhoudt voor een scherm. De invoer is leeg. De invoer is in een andere taal. In de data ontbreekt een veld. De betaling is nog in behandeling. De klant vraagt iets waar de functie nooit voor bedoeld was. Het model komt elk van deze situaties in de eerste week tegen; de eval hoort ze eerder te zijn tegengekomen.
De ongewone gevallen die iets kosten
Niet elk ongewoon geval verdient evenveel aandacht. De gevallen die je als eerste uitschrijft, zijn die waarin een fout antwoord geld, vertrouwen of een contact met support kost. Bij betalingen schrijft die lijst zichzelf. In andere domeinen duurt het langer, en dat uitzoeken is designonderzoek.
Toon, als regels die je kunt controleren
"Vriendelijk" is geen criterium. "Geeft de klant niet de schuld", "verontschuldigt zich hooguit één keer", "noemt de volgende stap in de eerste twee zinnen" zijn dat wel. Het meeste van wat een foutmelding laat werken is direct over te zetten, omdat een gegenereerd antwoord dat iemand vertelt dat er iets misging een foutmelding is, hoe de functie het ook noemt.
Welke fouten een release tegenhouden
Sommige criteria zijn hard: één verkeerd bedrag en de release gaat niet door. Sommige zijn zacht: een wat stijve formulering is acceptabel zolang die weinig voorkomt. Bepalen wat wat is, is een beslissing over wat het kost om fout te zitten, en dat is dezelfde beslissing die een designer neemt bij de keuze welke status als eerste ontworpen wordt.
Hoe het verschilt van een specificatie
Een specificatie, het document dat een team vertelt wat het moet bouwen, beschrijft één ding. Die wordt door een mens gelezen, meestal één keer, en daarna neemt het gebouwde product het over als bron van waarheid. Er mogen gaten in zitten, omdat de engineer die hem leest ze opvult, het liefst in overleg met de designer.
Een eval beschrijft een bereik van aanvaardbare output, omdat een generatieve functie nooit twee keer hetzelfde antwoord geeft. Hij wordt gelezen door een machine, bij elke wijziging, zolang de functie bestaat, en niets vervangt hem ooit, omdat de output nooit af is. En er mogen geen gaten in zitten. Een criterium dat een controleur niet op één output kan toepassen, is geen criterium, het is hoop.
Het vak is dus anders. Een specificatie ontwerpt een antwoord. Een eval ontwerpt de grens van een ruimte vol antwoorden, en bepaalt wat er aan de randen gebeurt.
Wie de pen vasthoudt
Engineers horen de machinerie te bouwen, de tools te kiezen en het geheel te draaien. Designers horen de criteria en de voorbeelden te schrijven, samen met product te bepalen hoeveel fouten van elke soort acceptabel zijn, en de foute outputs te lezen, omdat elke foute output een design review is die erop wacht te gebeuren.
Coding agents werken al zo, in kleinere vorm: je geeft ze geschreven standaarden omdat niemand meekijkt terwijl ze werken, en alles wat je wilt vasthouden moet ergens staan waar zij het lezen. Een AI-functie in productie is dezelfde situatie op grotere schaal. Niemand kijkt mee bij elke output. De criteria zijn het enige deel van de designer dat in de ruimte is.
Een design review beschermt één release. Als eval opgeschreven beschermt hij elke release daarna.