Klik op een element voor de inhoud
In februari 2025 postte Andrej Karpathy een bericht dat viraal ging. Hij noemde het vibe coding: je beschrijft in natuurlijke taal wat je wilt, AI genereert de code, en je leest de diffs niet eens meer. "I just see things, say things, run things, and copy paste things, and it mostly works." Het idee raakte een snaar — niet alleen bij hobbyisten, maar ook bij teams die dagelijks software bouwen. De belofte was helder: de afstand tussen idee en werkende code wordt nul.
Wie een jaar later kijkt, ziet een ander beeld. Karpathy zelf verving de term in februari 2026 door agentic engineering — een discipline, geen sfeer. Niet omdat het vibing niet werkte, maar omdat het zonder structuur niet bleef werken. De code die uit een vibe-sessie kwam draaide soms prima. Maar zodra je hem wilde testen, aanpassen of onderhouden, viel de onzichtbare technische schuld uit de kast. Er was geen spec. Er was geen validatie. Er was een vibe — en die vervloog.
Parallel verschoof het denken bij twee andere partijen die elk dezelfde kloof zagen, maar vanuit een andere hoek.
Bij OpenAI verscheen in dezelfde periode het concept harness engineering: niet betere prompts, maar betere structuur rondom AI-agents. De harness is het raamwerk dat bepaalt welke agent welke taak oppakt, hoe resultaten worden gevalideerd, en wanneer een mens terugkeert in de loop. Het is het besturingssysteem dat onder de agents draait — niet de agent zelf, maar het mechanisme dat de agent betrouwbaar maakt.
Bij Thoughtworks kristalliseerde een verwant idee: spec-driven development. De specificatie is het primaire artefact — niet de code. Code is het bijproduct, het laatste stuk van de keten. Wat je reviewt, wat je versiebeheerd, wat je valideert, is de spec. Alles wat erna komt is afleidbaar.
Drie onafhankelijke bewegingen. Drie antwoorden op hetzelfde probleem: hoe maak je van een menselijke intentie iets dat een machine kan valideren — zonder de mens uit de loop te halen? Vibe · Spec · Harness is het framework dat deze drie inzichten integreert.
Intentie vastleggen. Non-coder als actor. Exploratief, niet-formeel. AI is sparringpartner, niet implementeerder.
Intentie formaliseren. Gherkin, decision tables of event specs. BC-type bepaalt het formaat.
Intentie valideren. Specs worden executable. Feedback loop terug naar Vibe.
Op de Shapiro-ladder — het model dat we in het Augmented Organisation framework gebruiken om AI-integratie te meten — correspondeert dit met een bewuste route. L2, pair writing, voor de Vibe-fase: mens en AI samen, de mens stuurt. L4, intent-driven, voor Spec en Harness: AI genereert specificaties vanuit een intentie-omschrijving, de mens valideert of de spec de intentie correct weerspiegelt. Met een nadrukkelijke waarschuwing voor L3 — het niveau waarop AI specificaties schrijft zonder menselijke validatie. Op L3 propageer je aannames in plaats van ze te elimineren.
Het onderscheid is wezenlijk. Vibe coding was een intuïtie. Vibe · Spec · Harness is een methode.
Het is verleidelijk om Vibe · Spec · Harness te lezen als een lineaire pipeline. Dat is precies hoe het niet werkt.
De kracht zit in wat er tussen de fasen gebeurt. De Harness ontdekt gaten in de Spec — intentionele gaten, niet technische. De Spec disciplineert de Vibe — een intentie die je niet kunt vertalen naar een testbare specificatie is geen intentie, het is een wens. De Vibe verrijkt de Harness — edge-case agents die de intentie begrijpen, genereren relevantere scenario's.
En in elk van die drie loops speelt de bounded context-decompositie een andere rol. In de Vibe-loop bepaalt het BC-type met wie je praat en welke vraagstijl je gebruikt. In de Spec-loop bepaalt het welk formaat de vertaling krijgt. In de Harness-loop bepaalt het waar de agents draaien — binnen contexten én op de grensvlakken ertussen. Dezelfde decompositiebeslissing, drie manifestaties.
De drie fasen lopen niet volgtijdelijk maar parallel op verschillende frequenties. Vibe draait on demand. Spec draait op het ritme van de sprint. Harness draait continu — bij elke commit, bij elke deployment, bij elke nachtelijke run. Drie frequenties, één systeem.
Wie maar aan één fase werkt, komt vast. Vibing zonder specs produceert intenties die niemand valideert. Specs zonder harness produceert documenten die niemand uitvoert. Harness zonder vibe produceert tests die niemand begrijpt. Het is de samenhang die het laat werken — en het Bounded Context Canvas is de gemeenschappelijke taal die alle drie fasen verbindt.
De meeste requirements-processen beginnen met de vraag "wat wil je?" Dat klinkt redelijk. Maar het veronderstelt dat de gebruiker zijn intentie al kan articuleren. In de praktijk kan hij dat zelden — niet omdat hij onbekwaam is, maar omdat het kennis betreft die zo ingebed is in zijn dagelijkse werk dat hij haar niet meer als kennis herkent.
Neem de verzekeringsadviseur die al vijftien jaar geboortemeldingen verwerkt. Hij weet precies wat een jong gezin nodig heeft. Als je hem vraagt dat op te schrijven in een requirements-document, stopt hij bij "de klant wil een verzekering voor het kind." Dat is niet wat hij weet. Dat is wat hij kan formuleren. Tussen die twee zit een kloof — en in die kloof verdwijnen de meeste requirements.
De Hongaars-Britse wetenschapper Michael Polanyi introduceerde het begrip tacit knowledge: kennis die iemand bezit maar niet kan verwoorden. Zijn formulering — "we can know more than we can tell" — beschrijft precies het probleem dat requirements-elicitatie zo moeilijk maakt. De verzekeringsadviseur die weet dat adoptiegezinnen andere bescherming nodig hebben, handelt op basis van jarenlange ervaring die zich nooit in een document heeft genest. Die kennis is niet verloren — maar ze is ook niet toegankelijk via een vragenlijst. Ze moet worden uitgelokt, niet opgevraagd.
De Vibe-fase draait die aanpak om. Je vraagt niet wat iemand wil. Je provoceert reacties — en observeert wat er gebeurt. Dat is geen slordig begin. Het is een gestructureerde methode om tacit knowledge te activeren bij mensen die hun eigen kennis niet als kennis herkennen. De cyclus loopt van intentie naar specificatie — niet lineair, maar iteratief, in vijf stappen die elk een ander type kennis naar boven halen.
Het begint bij de intentie — de werkelijke vraag achter het verzoek. Bij de geboortemelding is de traditionele aanpak transactiegericht: gebruiker vult kindgegevens in, bladert door een productcatalogus, kiest zelf verzekeringen, klikt op opslaan. Wat de klant echt wil — het kind goed beschermd hebben — blijft volledig impliciet. Die intentie moet boven tafel komen voordat er iets anders kan gebeuren.
Zodra de intentie zichtbaar is, formuleer je een hypothese: hoe zou een oplossing eruitzien? Het systeem zou kunnen feliciteren en vragen: "Hoe wil je je kind beschermen — nu, over tien jaar, bij onverwachte situaties?" Verzekeringen worden afgeleid uit de antwoorden, niet gekozen uit een catalogus. Die hypothese is toetsbaar voordat er een regel code is geschreven.
De volgende stap maakt het concreet: een prototype — een klikbaar scherm of PDF, geen code. Wat de adviseur niet zegt, is minstens zo waardevol als wat hij wel zegt. Uit de reactie lees je signalen af — klikgedrag, aarzeling en verbazing zijn data. De adviseur die spontaan zegt "maar bij een adoptie is het anders" geeft je meer informatie in vijf woorden dan een uur gestructureerd interview. En ten slotte vloeit uit die signalen de specificatie voort: concrete, testbare vereisten die niet bedacht maar gevonden zijn.
Die cyclus werkt alleen als je de juiste vragen stelt. Bij vage "ik wil X"-formuleringen werkt verdiepen: socratisch doorvragen waarbij AI de intentielagen blootlegt door telkens één niveau dieper te gaan.
De techniek van vijf keer "waarom?" vragen komt uit het Toyota Production System, ontwikkeld door Taiichi Ohno in de jaren vijftig. Het oorspronkelijke doel was root cause analysis bij productiefouten: door vijf keer door te vragen naar het waarom achter een probleem, kom je voorbij de symptomen bij de onderliggende oorzaak. In de Vibe-fase dient dezelfde techniek een ander doel: niet het opsporen van een fout, maar het blootleggen van een intentie.
Vijf keer Waarom bij de geboortemelding: "Ik wil dat het systeem automatisch verzekeringen voorstelt." → Waarom? → "Omdat klanten niet weten welke producten passen." → Waarom niet? → "Omdat ons aanbod te complex is voor iemand die net een kind heeft gekregen." → Waarom is dat een probleem? → "Omdat ze dan niets kiezen of het verkeerde." → Waarom maakt dat uit? → "Omdat een onderverzekerd kind een risico is dat je op je geweten hebt." → Waarom is dat jóuw verantwoordelijkheid? → Stilte. Dan: "Omdat ik dit vak heb gekozen om mensen te beschermen, niet om producten te verkopen."
De intentie verschuift van "producten voorstellen" naar "bescherming als professionele verantwoordelijkheid." Dat is een fundamenteel ander uitgangspunt voor het systeem.
Als je prioriteiten boven tafel moet krijgen, werkt een geforceerde keuze beter: AI presenteert steeds twee varianten en observeert de voorkeur. Scenario-projectie werkt als je impliciete succescriteria zoekt: "Beschrijf een situatie over een jaar waarin dit perfect werkt." En het betwisten van aannames maakt grenzen zichtbaar: "Wat als dit niet beschikbaar was — wat zou je dan doen?"
In de praktijk combineer je deze stijlen met vier concrete technieken. Vijf keer Waarom + AI is de verdiepingsvraag met een gesprekspartner die niet vergeet wat je drie lagen geleden zei. Het provocatief prototype bouwt in twintig minuten een klikbaar scherm — bij de verzekeraar presenteerde het prototype drie beschermingsscenario's in plaats van een productcatalogus. De adviseur zei: "Maar waar is de optie voor als de ouder zelf ziek wordt?" Niemand had die vraag gesteld. Reactieve validatie vervangt open vragen door keuzevragen — open vragen produceren wenselijke antwoorden, keuzevragen eerlijke. En de intent diff vergelijkt na elke sprint de oude en nieuwe specificatieversie: waar is de intentie verschoven?
Op de Shapiro-ladder is dit L2: pair writing. De mens stuurt, AI stelt de vragen. De vibe is begrensd, niet vrij.
Tot nu toe hebben we de Vibe-fase beschreven aan de hand van de verzekeringsadviseur en de geboortemelding. Dat gesprek draait om een flow: een klant doorloopt een proces, het systeem reageert op elke stap. Scenario-projectie en provocatief prototype werken daar uitstekend.
Loop nu een gang verder en praat met de compliance officer van dezelfde verzekeraar. Haar domein ziet er fundamenteel anders uit. Geen flows, maar regels. Geen klantreizen, maar combinaties van condities die tot specifieke uitkomsten leiden. De vraag "beschrijf een situatie over een jaar waarin dit perfect werkt" levert hier weinig op — haar succescriterium is niet een tevreden klant maar een foutloze audit. Het betwisten van aannames werkt hier beter: "Wat als deze regel niet bestond — wat zou er misgaan?"
Eric Evans publiceerde Domain-Driven Design in 2003, en het centrale inzicht is eenvoudig: elk deel van een systeem spreekt zijn eigen taal. "Klant" betekent in de acceptatieafdeling iets anders dan bij de schadeafhandeling. Evans noemde het gebied waarbinnen een term eenduidig is een bounded context — en hij benadrukte dat het trekken van die grens geen technische keuze is maar een strategische.
De verzekeraar heeft minstens vier bounded contexts, elk met een ander type gedrag. Acceptatie is use case driven. Compliance is rule driven. Klantbeheer is CRUD/data driven. Claimverwerking is event driven.
Elk type vraagt een andere Vibe-aanpak. Bij use case driven contexten werkt scenario-projectie. Bij rule driven contexten het betwisten van aannames. Bij CRUD/data driven contexten reactieve validatie. Bij event driven contexten geforceerde keuze.
Die typering wordt expliciet gemaakt met Nick Tune's Bounded Context Canvas — een collaboratief ontwerptool dat per context vastlegt: naam en doel, strategische classificatie, domeinrollen, ubiquitous language, inbound en outbound communicatie.
| Dimensie | Opties |
|---|---|
| Belang voor de organisatie | Core domain · Supporting domain · Generic |
| Rol in het businessmodel | Revenue generator · Engagement creator · Compliance enforcer |
| Evolutiefase (Wardley) | Genesis · Custom built · Product · Commodity |
Een context die core domain is, revenue genereert en in de genesis-fase zit, verdient Vibe-sessies met de beste domeinexperts en zorgvuldig ontworpen specs. Een generic, compliance-gedreven context die al een commodity is, kun je afdekken met standaard schema contracts en geautomatiseerde tests.
En hier wordt het belang van vroege decompositie zichtbaar: als je bij Vibe al nadenkt over je bounded contexts, dan bouw je niet alleen een werkend systeem — je legt de basis voor een platform dat schaalt. Wanneer de adviseur zegt "ik wil dat het systeem automatisch de juiste verzekeringen voorstelt en dat de compliance-check direct meeloopt," hoor je twee contexten in één zin. Dat is het moment waarop de Vibe-fase de decompositie scherper maakt — en de decompositie de Vibe-fase stuurt.
De Spec-fase is het scharnierpunt. Hier wordt een menselijke vibe vertaald naar iets dat een machine kan valideren. De vibe is rijk, ambigu, contextueel. De spec is precies, testbaar, uitvoerbaar. Bij die vertaling verlies je onvermijdelijk iets — en de vraag is of je het juiste verliest.
Wat je wilt verliezen is ambiguïteit. Wat je niet wilt verliezen is de context die de spec betekenisvol maakt. Als de spec zegt "dekking mag niet negatief zijn" maar niemand meer weet waarom, is de spec een zombie — levend maar zonder ziel.
De cyclus binnen de Spec-fase loopt iteratief in vijf stappen: intentie ophalen en expliciteren — niet interpreteren, maar reconstrueren. Die intentie vertalen naar spec-taal. AI genereert een specificatie als voorstel. De domeinexpert valideert. Bijstellen en opnieuw door de cyclus. Elke ronde vergroot de precisie.
Die cyclus heeft een communicatieformaat nodig. En hier wordt de domeindecompositie uit de Vibe-fase operationeel: het type bounded context bepaalt welk formaat past.
Toen Dan North in 2006 Behaviour-Driven Development formuleerde, was zijn motivatie niet het schrijven van betere tests. Zijn motivatie was het voeren van betere gesprekken. North zag dat ontwikkelteams en domeinexperts langs elkaar heen praatten — niet door technische onkunde, maar door het ontbreken van een gedeelde taal. Given-When-Then was zijn oplossing: een structuur die eenvoudig genoeg is voor een niet-technisch persoon om te lezen, en formeel genoeg voor een machine om uit te voeren. In Vibe · Spec · Harness herstellen we de oorspronkelijke intentie: de spec als communicatiemiddel, niet als testscript.
Voor de acceptatie-context — use case driven — is Gherkin het natuurlijke formaat. De vibe was: "Ik wil mijn kind goed verzekerd hebben." In de Spec-fase wordt dat:
Feature: Geboortemelding verwerken Scenario: Ouder wil bescherming tegen inkomensverlies Given een pasgeboren kind And een ouder met actief account When de ouder bescherming wil tegen onverwacht inkomensverlies Then wordt een overlijdensrisicoverzekering voorgesteld And bevat het voorstel een dekking gebaseerd op het huidige inkomen Scenario: Adoptiekind aanmelden Given een geadopteerd kind And juridische documentatie is beschikbaar When de ouder bescherming wil Then worden dezelfde beschermingsopties voorgesteld And worden juridische wachttijden gerespecteerd
De spec is leesbaar voor de verzekeringsadviseur. En uitvoerbaar voor de agent die het systeem valideert. Dat is de brug die Dan North bedoelde: niet een testtaal, maar een gesprekstaal.
Voor de compliance-context werkt Gherkin niet. Wie Gherkin schrijft voor een rule-driven context, schrijft scenario's voor elke regelcombinatie en heeft er honderden nodig. De vibe was: "We moeten compliant zijn zonder de klantervaring te verslechteren." In de Spec-fase wordt dat een decision table:
| Klanttype | Product | Leeftijd | Max. dekking | Validatie |
|---|---|---|---|---|
| Particulier | Overlijdensrisico | < 65 | 200% jaarinkomen | Automatisch |
| Particulier | Overlijdensrisico | ≥ 65 | 150% jaarinkomen | Handmatig |
| Zakelijk | Overlijdensrisico | n.v.t. | Onderhandeld | Altijd handmatig |
| Particulier | Aanvullend | < 18 | N.v.t. | Via ouder |
Plus een property die als invariant geldt: "Voor geen enkele combinatie van klanttype, product en leeftijd mag de berekende dekking negatief zijn." De compliance officer herkent zijn regels. De actuaris herkent de grenzen. En de harness kan de tabel exhaustief doorlopen.
Bij CRUD/data driven contexten is het spec-formaat schema contracts en API-specificaties (OpenAPI). Bij event driven contexten is het formaat event specs en saga-definities: "Als betaling ontvangen niet binnen 24 uur volgt op bestelling geplaatst, wordt de voorraadreservering vrijgegeven."
Achter deze formatvariatie zit één constant principe. Thoughtworks' inzicht over spec-driven development verandert fundamenteel waar je als team je aandacht op richt. In traditionele ontwikkeling is code het artefact. In spec-driven development verschuift dat: de specificatie is het artefact, code het bijproduct. De vraag verschuift van "doet deze code wat hij moet doen?" naar "beschrijft deze spec wat we bedoelen?" — een validatievraag die domeinkennis vereist, geen technische expertise. De verzekeringsadviseur kan de Gherkin-spec valideren. De Java-code niet.
Op de Shapiro-ladder is dit L4: de domeinexpert wordt eigenaar van het artefact, de engineer wordt eigenaar van de executie.
| BC-type | Spec-formaat | Wie valideert |
|---|---|---|
| Use case driven | Gherkin scenarios | Domeinexpert / product owner |
| Rule driven | Decision tables · property-based specs | Compliance officer / actuaris |
| CRUD / data driven | Schema contracts · OpenAPI | Data-architect / product owner |
| Event driven | Event specs · saga-definities | Proceseigenaar / domeinexpert |
De harness is geen testsuite. Het is het besturingssysteem rondom AI-agents — de structuur die ervoor zorgt dat specs daadwerkelijk worden uitgevoerd, gevalideerd en teruggekoppeld. OpenAI's concept van harness engineering maakt het onderscheid scherp: het probleem is niet dat we betere prompts nodig hebben. Het probleem is dat we betere structuur nodig hebben rondom de agents die de prompts uitvoeren. Zonder die structuur is een agent een losse kracht zonder richting.
De eerste component is spec-executie: AI voert de specificaties uit als geautomatiseerde tests. Bij de geboortemelding draait de agent de Gherkin-scenario's stap voor stap. Bij de compliance-regelmotor draait de agent de decision table af. Falende specs zijn informatie, geen fouten — ze vertellen je waar de spec onvolledig is, niet waar de code kapot is.
De tweede component is de agent-structuur. Het BC-type bepaalt ook hier de strategie. Bij use-case-driven contexten draait één agent happy-path scenarios terwijl een tweede edge cases genereert. Bij rule-driven contexten loopt een agent de decision table af terwijl een tweede property-based tests genereert. Bij event-driven contexten speelt een agent de standaard volgorde af terwijl een tweede de volgorde bewust verstoort.
De harness bepaalt niet alleen welke agents draaien, maar ook wanneer ze terugkoppelen: stilte bij succes, alarm bij ontdekking.
Drie typen agents in de harness: spec-executie agents voeren bestaande specs uit. Spec-discovery agents zoeken gaten — scenario's die niet zijn gespecificeerd. Integration agents bewaken de grensvlakken tussen bounded contexts. Een executie-fout stuurt je terug naar de Spec-fase. Een ontdekking stuurt je terug naar de Vibe-fase.
De vier bounded contexts van de verzekeraar communiceren met elkaar. Als de acceptatie-context een polis aanmaakt, moet klantbeheer de master data bijwerken. Als compliance een dekkingsgrens wijzigt, moet acceptatie dat verwerken. Die integration points zijn precies de plekken waar specs het vaakst onvolledig zijn — omdat ze buiten het blikveld van één domeinexpert vallen.
Integration agents valideren of de uitgaande berichten van context A passen op de verwachtingen van context B. Een partnership vereist bidirectionele contract tests. Een customer-supplier relatie vereist tests die de leverancier dwingt zijn contract na te komen. Een anti-corruption layer vereist tests die valideren dat de vertaling correct is.
De Shapiro-ladder beschrijft vijf niveaus: L1 (handmatig), L2 (pair writing — mens stuurt, AI assisteert), L3 (AI genereert zonder menselijke validatie), L4 (intent-driven — AI genereert vanuit intentie, mens valideert) en L5 (autonoom). De ladder maakt zichtbaar dat er geen lineaire progressie is van "minder AI" naar "meer AI". L3 is nadrukkelijk een risiconiveau: AI die plausibele maar ongevalideerde output produceert. Het framework stuurt bewust van L2 (Vibe) naar L4 (Spec, Harness) — en slaat L3 over.
Spec-resultaten vloeien terug naar de Vibe-fase. Wat niet testte, blijkt geen spec te zijn geweest — het was een aanname.
Scenario: Adoptiekind aanmelden Given een geadopteerd kind When de ouder bescherming wil tegen inkomensverlies Then ... [geen spec beschikbaar]
Geen fout in de code — een gat in de intentie. De feedback loop stuurt dit terug. Nieuwe vragen: "Verschilt de beschermingsbehoefte bij adoptie? Zijn er juridische aspecten?" Nieuwe intentie wordt expliciet. Nieuwe specs worden gegenereerd. De cyclus draait opnieuw.
Bij de compliance-regelmotor ontdekt de agent dat een combinatie tot een negatieve dekking leidt. Bij de event-driven claimverwerking ontdekt de replay-agent dat een event-volgorde tot een dubbele reservering leidt. In alle gevallen: de harness vindt het gat, de Vibe-fase vult het.
| BC-type | Harness-strategie | Feedback-type |
|---|---|---|
| Use case driven | E2E tests, flow-validatie | Welke flow is niet afgedekt? |
| Rule driven | Property-based testing, invariant checks | Welke regelcombinatie is inconsistent? |
| CRUD / data driven | Contract testing, data-validatie | Welke datastructuur is veranderd? |
| Event driven | Event replay, temporele tests | Welke event-volgorde breekt? |
| Tussen contexten | Integration agents, contract tests | Welk grensvlak is inconsistent? |
Vibe maakt de intentie zichtbaar.
Spec maakt haar testbaar.
Harness maakt haar duurzaam.
Dit whitepaper maakt deel uit van de Augmented Software Engineering reeks.
April 2026