Een waarschuwing vooraf: dit is een technisch essay. Geen tips, geen lijstje, geen verkooppraat. Ik beschrijf een manier om werk vast te leggen die anders is dan wat de meeste bedrijven doen, en ik ga de diepte in omdat het pas overtuigt als je de mechaniek ziet. Neem er de tijd voor, of bewaar het voor als je die hebt.
Elk bedrijf houdt een kasboek bij. Niemand vindt dat gek. Je legt niet vast wat je saldo is, je legt vast wat er gebeurde: een factuur, een betaling, een correctie. Het saldo is geen invoerveld, het is een uitkomst. En daarom kun je erop terugkijken. Als het saldo raar is, loop je de boekingen na tot je ziet waar het kantelde.
Nu je werk. Waar staat dáár de boeking?
Nergens. Wat je hebt is een verzameling velden waarin de laatste toestand staat. Status: in productie. Levering: verwacht. Project: loopt. Wie dat veld heeft gezet, wanneer, en waarom, is weg. Wat er vorige week stond weet niemand meer. En als je vraagt hoe het kan dat dit project verlies draait, begint het gissen.
We boeken geld al zeshonderd jaar als mutaties. Ons werk boeken we als een schoolbord dat we steeds schoonvegen.
Dit essay gaat over wat er gebeurt als je die omkering maakt. Ik heb het niet alleen bedacht maar ook gebouwd, als draaiende simulatie van een interieurbouwfabriek, en ik gebruik dat hier als voorbeeldmateriaal.
Een feit is iets dat gebeurd is
Begin bij het kleinste onderdeel. Een feit.
Een feit is iets wat gebeurd is en dus niet meer verandert. "Levering aangekomen." "Zaagfout geconstateerd." "Klant keurt de tekening goed." "Anna heeft de calculatie afgerond, uitkomst: risico onzeker."
Geen status, geen mening, geen veld dat iemand later bijwerkt. Een gebeurtenis, met een tijdstip, met wie het deed, en met de gegevens die erbij horen.
Die feiten zet je achter elkaar in één lijst en je haalt er nooit iets uit weg. Dat is de hele opslag.
Klinkt te simpel om ergens toe te leiden, maar er zit een eigenschap in die alles verandert: alles wat je verder wilt weten is afleidbaar. Wat staat er in productie? Tel de feiten. Hoe druk is de planning? Tel de openstaande vragen. Wat was de stand op 3 maart om vier uur? Tel tot dat punt en stop.
Je bouwt geen schermen meer die de waarheid bevatten. Je bouwt uitzichten op dezelfde stapel feiten.
En dat betekent ook: je kunt terug in de tijd. Niet als feature, maar omdat het niet anders kan.
Spelregels zijn wat er uit een feit volgt
Feiten alleen zijn een archief. Wat een bedrijf laat draaien zijn de regels ertussen.
Een spelregel is een zin van de vorm: als dit feit ontstaat, dan volgt dat. Als de tekening is goedgekeurd, dan moet er een materiaalstaat komen. Als de materiaalstaat er is, dan ontstaat er bestelbehoefte per artikel. Als een levering binnenkomt, dan moet iemand hem controleren voor hij de voorraad in gaat.
Dat is precies wat er in de hoofden van je mensen zit. Het staat alleen nergens, of het staat in een werkinstructie die niemand leest, of het zit begraven in code die niemand meer durft aan te raken.
Zet die regels apart, als data. Dan kun je ze lezen, bespreken, tekenen en veranderen zonder dat je een systeem hoeft te verbouwen.
Elk gevolg-feit onthoudt bovendien welke feiten hem veroorzaakt hebben. Dat lijkt een detail voor programmeurs, maar het is de reden dat je later "waarom" kunt vragen zonder te reconstrueren.
Wat het bovendien oplost: de eeuwige ruzie over wat het proces is. Als de regels expliciet zijn, is er geen discussie meer over wat er hoort te gebeuren. Alleen nog over of de regel klopt. Dat is een veel productiever gesprek.
Werk vragen aan een mens is ook een feit
Hier gaat het vaak mis in dit soort systemen: ze modelleren alleen de machinerie en niet de mensen.
Maar een vraag aan een mens is net zo goed een gebeurtenis. "Er is werk voor de inkoop: plaats een order voor kantenband." Dat feit maakt geen taak in een takenlijst aan. Het ís de taak. Iemand pakt hem op, dat is weer een feit. Iemand handelt hem af met een uitkomst, dat is het derde feit.
En dan de belangrijkste vondst: die uitkomst is geen vinkje.
"Gereed" is één mogelijkheid. "Niet aangetroffen" is er ook een. "Aantal te weinig." "Bouwplaats niet gereed." "Kan niet, omdat..." met vrije tekst erachter.
Vindt de magazijnmedewerker het spul na de zoekactie alsnog, dan corrigeert hij zijn eigen waarneming, en die correctie is opnieuw een feit dat naar het oude feit verwijst. Het oude feit blijft staan. Je mag je vergissen in dit model, je hoeft alleen niet te doen alsof het niet gebeurd is.
Dit is de reden dat dit soort systemen wél gevuld worden en klassieke systemen niet. Je vraagt mensen niet om administratie bij te werken. Je vraagt ze om hun werk af te melden met de uitkomst die er echt was. De administratie is het gevolg.
De praktische regel die ik daarbij hanteer, noem ik de registratieladder. Als een machine het zelf kan melden, laat de machine het melden. Kan dat niet, gebruik een scan. Kan dat niet, leid het af uit andere feiten. En pas als het echt niet anders kan, vraag je het aan een mens. Elke stap omlaag op die ladder kost betrouwbaarheid, dus je gebruikt hem zo min mogelijk.
Poorten: waar stromen samenkomen
De meeste processen tekenen we als een lijn. In werkelijkheid zijn het beken die samenkomen.
Een module kan pas de spuiterij in als álle onderdelen gemeten zijn. Productie kan pas beginnen als álle artikelen binnen zijn, niet de meeste. De montage kan pas als het transport er is én de bouwplaats vrij is.
Zulke punten noem ik poorten. Een poort telt af.
En dat is precies de vraag waar je als directeur mee zit: waar staat het stil, en waarop wacht het? Bij poorten is dat geen speurwerk meer.
Het interessantste feit is het feit dat uitblijft
Dit is voor mij de kern van het hele model, en het is ook het minst intuïtieve stuk.
Alles tot nu toe gaat over dingen die gebeuren. Maar het meeste geld verdwijnt in dingen die níet gebeuren. De levering die uitblijft. De klant die niet reageert op de kleurstalen. De goedkeuring die blijft liggen.
Te laat zijn is geen gebeurtenis. Niemand "doet" te laat. Er gebeurt juist niets.
Dus moet je de afwezigheid zelf tot feit maken. Dat gaat zo: leg de belofte vast op het moment dat hij wordt gedaan. "De leverancier heeft toegezegd te leveren op dinsdag." Dat is iets wat gebeurd is, dus dat kan gewoon in de log. En zet er een bewaker op die op dinsdag kijkt of het beloofde feit er is.
Is het er, dan zwijgt de bewaker. Is het er niet, dan maakt hij er een feit van, met een verwijzing naar de belofte die niet is nagekomen.
Tel die twee soorten een jaar lang en je hebt een leverbetrouwbaarheidscijfer per leverancier dat niemand heeft hoeven invoeren.
Hetzelfde mechanisme werkt overal waar iets beloofd wordt. Een opleverdatum aan een klant. Een goedkeuring die je hebt gevraagd. Een taak die veel te lang blijft liggen. Het is steeds dezelfde vorm: leg de verwachting vast, zet er een controlemoment op, en maak van de afwezigheid een feit.
En als het beloofde alsnog binnenkomt, sluit de bewaker de lus: alsnog gehaald, drie dagen te laat. Ook dat is een feit, en daarmee dooft het probleem vanzelf uit in plaats van dat er een vlaggetje blijft hangen dat niemand meer weghaalt.
Wat je er gratis bij krijgt
Als je zo bouwt, komen er dingen uit die je normaal als apart project zou moeten kopen.
Waarom-vragen. Elk feit weet welke feiten hem veroorzaakt hebben. Dus kun je vanaf een probleem terug: de module past niet, want de maatvoering week af, want de tekening is nooit herzien na het inmeten, want de vraag daarover bleef drie weken liggen bij iemand die ziek was. Dat is geen reconstructie uit mailtjes. Dat is een ketting die er al ligt.
Tijdreizen. Je kunt naar elk moment terug en de hele organisatie zien zoals hij toen was. Niet alleen wat er gebeurde, maar ook wat men toen dácht dat er zou gebeuren, want ook verwachtingen zijn vastgelegd. Dat maakt terugkijken eerlijk. Je beoordeelt een beslissing met de kennis van toen, niet met de kennis van nu.
Nacalculatie die klopt. Als elke afgehandelde taak zijn uren draagt en elke machine zijn draaitijd, dan is de werkelijke kostprijs geen schatting achteraf maar een optelsom. In mijn simulatie draait ongeveer een op de drie projecten verlies terwijl ze op papier allemaal winst maakten. Niet door één ramp, maar door een stapeling van kleine dingen die nergens werden vastgelegd.
Dashboards zonder invoer. Doorlooptijden, verzuim, storingen, hoe vaak een afspraak gehaald wordt: het is allemaal een telling. Niemand hoeft een rapportage bij te werken, want er is geen rapportagewaarheid naast de operationele waarheid.
De boom: alle wegen die de regels toelaten
Als je de regels als data hebt, kun je ze tekenen. En dan gebeurt er iets wat ik zelf niet had zien aankomen.
Alle regels samen vormen één boom. Onderaan de aanvraag, bovenaan het afgesloten project, en daartussen elk pad dat de regels toelaten. Niet alleen het nette pad. Ook de zaagfout die terug de lijn in gaat. Ook de klant die zich bedenkt. Ook de leverancier die niets van zich laat horen.
Dat is een verrassend krachtig beeld om samen naar te kijken. Mensen zien meteen: hier zitten al onze uitzonderingen, en dit is de weg die dit project heeft afgelegd. Ze zien ook de lussen, de plekken waar werk terugkomt. Herstel is geen uitzondering in een fabriek, het is een deel van de vorm.
En je ziet waar het druk is. Zet er de lopers van vandaag bij, als lichtjes, en de boom vertelt je waar in het proces je bedrijf op dit moment staat.
Waar AI thuishoort, en waar niet
Nu de vraag waar iedereen mee begint terwijl hij eigenlijk het laatst komt.
Met een model als dit kun je precies aanwijzen wat een regel wél kan. Bepalen dat een levering te laat is, dat kan een regel. Een rappel uitzetten, orders bundelen voor dezelfde leverancier, een factuur klaarzetten bij een mijlpaal: allemaal regels. Dat hoeft geen AI te zijn, en het moet ook geen AI zijn, want een regel is voorspelbaar, goedkoop en uitlegbaar.
Waar houdt het op? Bij de situaties waar de mogelijkheden oneindig zijn en de afweging situationeel.
De leverancier reageert nergens meer op, het contract heeft een boeteclausule, het alternatief is drie keer zo duur en de klant heeft vorige week al een keer moeten wachten. Wat doe je? Daar bestaat geen regel voor, en die ga je ook nooit schrijven, want er zijn te veel varianten.
Dat is de plek voor AI. Niet als laag over alles heen, maar als spelregel voor het onvoorziene. Op het moment dat de keten vastloopt en geen enkele regel past, bedenkt de AI een aanpak. Geen antwoord uit een keuzelijstje, maar een klein plan: drie of vier stappen, elk met een afdeling erbij en met condities. De klant pas informeren als het spoedspoor faalt, bijvoorbeeld.
Dat plan wordt een feit, met de motivatie erbij. En dan gebeurt het aardigste: het voert zichzelf uit via de gewone werkbak. Elke stap wordt echt werk voor een echte afdeling, met een echte uitkomst. Geen apart AI-systeem naast het proces, maar werk in dezelfde stroom, alleen bedacht door iemand anders.
Twee dingen maken dit netjes in plaats van eng.
Ten eerste de grens. Een AI mag voorstellen, niet toezeggen. Geld uitgeven, een datum beloven aan een klant, meerwerk accepteren: dat blijft een goedkeuring van een mens. Die grens is geen beleidsregel in een handboek, hij zit in het model als een verplicht paar feiten: eerst gevraagd, dan verleend.
Ten tweede de herhaling. Als dezelfde aanpak twee keer werkt, is het geen uitzondering meer. Dan stelt het systeem voor om het als vaste spelregel op te nemen. Het onvoorziene wordt gewoon proces, en je kunt teruglezen wanneer die regel is ontstaan en waarom.
Agenten als capaciteit, met een mandaat
Nog een stap verder. Als het werk in een werkbak zit en elke taak een gedefinieerde uitkomst heeft, wat let je dan om een deel van dat werk door een agent te laten doen?
Niet alles. Iemand moet nog steeds op de bouwplaats inmeten en een kast monteren. Maar bestellen, factureren, rappelleren, inplannen: dat is digitaal, regelgebonden en controleerbaar werk.
In mijn simulatie pakken agenten daarmee ongeveer een zesde van alle taken op. Ze werken snel, ze worden niet ziek, en als de rij oploopt schakelt het systeem er een bij. Dat laatste is een verschil dat je niet kunt wegpoetsen: capaciteit van mensen is een vaste grootheid, capaciteit van agenten niet.
Belangrijker dan de snelheid is wat ze daarna doen. Ze kijken hun eigen werk na. Vinden ze iets, dan herstellen ze het zelf, en dat is een feit dat je kunt tellen. En stuiten ze op een oordeel dat niet aan hen is, dan geven ze de taak terug aan een mens, met een reden.
Daarmee krijg je een cijfer dat ik in geen enkel bedrijf ooit heb gezien: welk deel van ons werk is delegeerbaar, hoe vaak vangt de delegatie zijn eigen fout, en hoe vaak moet er alsnog een mens aan te pas komen.
En als je dat eenmaal hebt, kun je ook op intentie sturen. Je typt een zin: zorg dat de projecten die te laat dreigen te komen deze week voorrang krijgen. Dat is een feit van jou. De AI maakt er een plan van, het plan wordt werk, het werk wordt gedaan, en je krijgt terug of het gelukt is. Je hebt geen procedure geschreven. Je hebt een intentie uitgesproken in een systeem dat weet wat werk is.
Ik heb het gebouwd om te weten of het klopt
Praten over procesmodellen is makkelijk. Dus heb ik een fabriek gebouwd.
Geen presentatie, een werkende simulatie van een interieurbouwbedrijf: drieënveertig mensen, elf machines, leveranciers die te laat leveren of niets laten horen, klanten die van kleur veranderen als de productie al draait, ziekmeldingen, bouwvak, zaagfouten, meerwerk dat mondeling geregeld wordt en pas bij de nacalculatie opduikt. Een jaar draaien levert tienduizenden feiten op, allemaal aan elkaar geknoopt.
Wat ik wilde weten, was of het model standhoudt als je de werkelijkheid erin propt. Ik heb vier keer een hele laag toegevoegd: machines met omsteltijden en proefstukken, mensen met verlof en inwerktijd, klanten die zich bedenken, geld en nacalculatie. Geen enkele keer hoefde ik de architectuur aan te raken. Alleen de spelregels groeiden.
Dat is voor mij het echte bewijs. Niet dat het er mooi uitziet, maar dat complexiteit toevoegen geen verbouwing werd.
Wat er allemaal mee kan
Ik heb dit gebouwd als fabriek omdat een fabriek concreet is. Maar er zit niets fabrieksachtigs in het model.
Wat je nodig hebt is dit: werk met een doorlooptijd, meerdere mensen die elkaar iets overdragen, afspraken met de buitenwereld, en dingen die misgaan. Dat is een installatiebedrijf, een aannemer, een kantoor met dossiers, een zorgtraject, een gemeente met vergunningen, een softwareteam. Overal waar iets van A naar B moet en onderweg door handen gaat.
Wat het je daar oplevert is steeds hetzelfde rijtje. Je weet wat er echt gebeurde, en waarom. Je ziet waar het stilstaat en waarop het wacht. Je bewaakt je eigen beloftes in plaats van dat je klanten je erop wijzen. Je weet wat een opdracht werkelijk heeft gekost. En je kunt een onderbouwd antwoord geven op de vraag welk werk je kunt uitbesteden aan een machine en welk werk oordeel is.
Wat het niet is
Laat me eerlijk zijn over de andere kant, anders klinkt dit als een folder.
Dit is geen softwarepakket dat je installeert. De kern is denkwerk: het opschrijven van je eigen spelregels. Dat is precies het stuk dat bedrijven het liefst overslaan, want het is ongemakkelijk. Je komt erachter dat drie afdelingen een ander idee hebben van hetzelfde proces. Dat is geen bug in de methode, dat ís de opbrengst, maar het voelt de eerste week niet zo.
Het is ook geen excuus om alles te willen registreren. Als je mensen vraagt om elke handeling af te vinken, heb je geen model gebouwd maar een prikklok. De registratieladder is er niet voor niets.
En het is niet gratis. Een log die alles bewaart wordt groot, uitzonderingen blijven bestaan, en de eerste versie van je regels klopt niet. Dat mag, want regels aanpassen is bij dit model goedkoop. Maar reken niet op een systeem dat af is. Reken op een systeem dat meegroeit.
De voorsprong gaat naar wie durft los te laten
Er ontstaat de komende jaren een verschil tussen bedrijven dat groter wordt dan de meeste mensen nu inschatten. En het zit niet waar iedereen kijkt.
Het zit niet in welk model je kiest. Modellen worden elk kwartaal beter en ze zijn voor iedereen te koop. Wie vandaag de beste assistent heeft, heeft over een half jaar dezelfde als zijn concurrent. Daar zit geen voorsprong.
De voorsprong zit in of een bedrijf bereid is los te laten waar het aan vasthoudt. Het pakket waar drie ton in is gaan zitten en dat daarom heilig is geworden. Het statusveld dat al twaalf jaar hetzelfde heet terwijl niemand meer weet wie het zet. De collega die alles in zijn hoofd heeft en over vier jaar met pensioen gaat. En vooral: de overtuiging dat ons proces te bijzonder is om op te schrijven.
Dat loslaten is geen technische stap, het is een ongemakkelijke. Wat je opgeeft is de vaagheid, en vaagheid is comfortabel. Zolang het proces in hoofden zit, kan iedereen gelijk hebben. Zodra het op tafel ligt, blijkt dat drie afdelingen iets anders bedoelden, en dat er werk is dat niemand ooit heeft toegewezen.
Maar wie dat wel doet, krijgt iets wat je niet kunt kopen. Je kunt werk pas serieus uitbesteden aan een machine als vastligt wat het is, wanneer het klaar is en hoe je dat controleert. Dat geldt voor een agent net zo hard als voor een nieuwe medewerker. Delegeren is geen kwestie van vertrouwen, het is een kwestie van definitie.
En het stapelt. Elke uitzondering die je vastlegt maakt het model scherper, elke scherpere regel maakt het volgende stuk delegeerbaar, en elke delegatie geeft je mensen tijd voor het werk waar oordeel bij hoort. Een bedrijf dat die lus twee jaar draait, haal je niet in door een beter model aan te schaffen. Je zou zijn hele manier van kijken moeten inhalen.
Wie AI serieus wil inzetten, moet dus eerst iets durven opgeven. Dat is de prijs, en dat is meteen waarom de meesten het niet doen.
Tot slot
De reden dat dit werkt is niet de techniek. Het is de omkering.
Zolang je alleen de huidige toestand bewaart, moet je alles wat je wilt weten opnieuw verzinnen: rapportages, statusoverleggen, iemand die het toevallig nog weet. Zodra je vastlegt wat er gebeurde, is elk antwoord een telling.
Je hoeft daar niet in te geloven. Je doet het al met je geld.
De vraag is alleen waarom je je werk, dat veel duurder is dan je saldo, nog steeds op een schoolbord bijhoudt.
Wil je de simulatie zien draaien? Ik laat hem graag een keer zien: je schuift dan zelf door het jaar, klikt een project open en ziet waar het misging. Neem contact op.