7 oktober 2026Bijgewerkt op Fathy Shalaby13 min leestijd
Een beslissingsgraaf voor kleine AI-teams: context die zich opbouwt
Kleine teams hebben geen gebrek aan notities. Ze missen de verbanden tussen bewijs, beslissingen, werk en uitkomsten. Een praktisch model voor een beslissingsgraaf, een kopieerbaar logboek en de test die laat zien of die van jou werkt.
Een beslissingsgraaf is een vastlegging die vier dingen met elkaar verbindt: het signaal dat veranderde wat een team geloofde, de beslissing die het nam, het werk dat die beslissing opleverde en de uitkomst die terugkwam. Kleine AI-native teams hebben er een nodig omdat hun context in twee of drie hoofden zit. Zonder de verbanden wordt "waarom hebben we dit gebouwd?" uit het hoofd beantwoord, of helemaal niet.
Belangrijkste punten
Teams besteden volgens Atlassians State of Teams 2025 meer dan 25% van hun werkweek aan het zoeken naar informatie (Atlassian, 2025). Ontbrekende beslissingscontext is een groot deel van dat zoeken.
De mediane diensttijd in de VS was in januari 2026 4,1 jaar, en 3,0 jaar voor werknemers van 25 tot 34 jaar (BLS, 2026). In een klein team vertrekt de persoon die weet waarom eerder dan je denkt.
Engineers losten de helft van dit probleem in 2011 op: Michael Nygards architecture decision record heeft vijf velden en bestaat om "blind accepteren of blind terugdraaien" van oude keuzes te voorkomen (Nygard, 2011).
Een beslissingslogboek somt keuzes op. Een graaf verbindt ze met bewijs ervoor en uitkomsten erna. Die verbanden zorgen dat het team leert.
Eén test laat zien of die van jou werkt: kan een nieuwe collega van een klantsignaal naar de beslissing, het werk en het resultaat komen zonder iemand te vragen?
Waarom verliezen kleine teams hun productcontext?
Kleine productteams hebben zelden een tekort aan informatie. Ze hebben informatie die je niet twee keer kunt gebruiken.
Er is een klantinterview. Een oprichter neemt een beslissing. Een engineer levert een wijziging op. Een metric beweegt, of niet. Drie maanden later herinnert het team zich fragmenten van het verhaal, maar niet de keten die het signaal met de beslissing verbond. De dure versie van wat mensen "productgeheugen" noemen, is een stapel correcte notities waarna het team zich nog steeds afvraagt waarom.
Drie dingen maken dit erger bij kleine AI-native teams:
Context zit bij een of twee mensen. Dat voelt efficiënt tot iemand erbij komt, een prioriteit verandert of de oorspronkelijke beslisser zich zes maanden later de redenering niet meer herinnert.
Mensen vertrekken. Met een mediane diensttijd van 3,0 jaar voor 25- tot 34-jarigen (BLS, 2026) moet een team van vijf rekenen op regelmatig vertrek. Als grove rekensom, niet als voorspelling: als iedereen ongeveer drie jaar blijft, verliest een team van vijf ongeveer elke zeven maanden iemand.
AI versnelt output, niet het vastleggen van redeneringen. Een coding agent kan in een middag een functie bouwen. Hij legt niet vast waarom die functie de moeite waard was, en bouwt graag iets opnieuw waar het team vorig kwartaal tegen besloot als niemand dat heeft opgeschreven.
Wat is het verschil tussen opgeslagen kennis en bruikbare context?
Een document vertelt je wat iemand heeft opgeschreven. Bruikbare context vertelt je wat het team geloofde, welk bewijs dat geloof vormde, wat er daarna veranderde en wat nog onzeker is.
Een document is meestal georganiseerd rond een gebeurtenis: een interviewsamenvatting, een PRD, een roadmapupdate, een lanceringsnotitie, een statusrapport. Een beslissing is georganiseerd rond een vraag:
Welk klantprobleem moeten we eerst oplossen?
Wat nemen we aan?
Wat zou deze gok fout maken?
Welk werk volgt als we ons committeren?
Wanneer weten we of het werkte?
De eerste structuur is goed om iets terug te vinden. De tweede is goed om te oordelen. Een map met goed geschreven documenten kan het team toch tekortdoen, omdat de verbanden ertussen nooit zijn vastgelegd.
Hoe ziet een beslissingsgraaf eruit? Signaal → Beslissing → Werk → Uitkomst
Een praktische versie is gebouwd rond vier verbonden objecten.
1. Signaal
Een signaal is iets dat kan veranderen wat je doet: een herhaald klantverzoek, een supportpatroon, een interviewwaarneming, een verandering in gebruik, een verkoopbezwaar, een technische beperking. Een signaal is niet automatisch een requirement. Het is bewijs dat interpretatie verdient.
Nuttige velden:
Wat gebeurde er?
Waar kwam het vandaan (met een link naar de bron)?
Wie of wat vertegenwoordigt het?
Hoe vaak is het voorgekomen?
Wat suggereert het?
Wat bewijst het niet?
De laatste vraag is belangrijk. Eén luid verzoek kan echt zijn zonder representatief te zijn. Ons overzicht van wat als bewijs telt voor elk productrisico laat zien welke signalen gewicht hebben voor welke vraag.
2. Beslissing
Een beslissing legt de toezegging vast die het team deed als reactie op het signaal. Een duurzame beslissing heeft vijf delen:
De vraag die wordt beantwoord.
De gemaakte keuze.
De overwogen alternatieven.
Het bewijs en de aannames erachter.
De voorwaarde waaronder het team de beslissing opnieuw zou bekijken.
Het vijfde veld maakt van een logboek een leersysteem. Zonder dat veld is het logboek een archief van meningen. Mét dat veld kan het team zien of een beslissing fout, voorbarig of juist was voor de informatie die er toen was.
Dit weerspiegelt het architecture decision record dat Nygard in 2011 voorstelde, met Title, Context, Decision, Status en Consequences (Nygard, 2011). Zijn argument geldt ook voor productkeuzes: een nieuwkomer die voor een onverklaarde beslissing staat, kan haar alleen blind accepteren of blind terugdraaien, en beide zijn riskant.
3. Werk
Werk is de concrete uitdrukking van de beslissing: een specificatie, experiment, ticket, prototype, workflow of klantgesprek.
Werk aan beslissingen koppelen voorkomt een veelvoorkomende fout. Teams voeren een doordacht strategiegesprek en leveren daarna werk zonder zichtbare relatie ermee. Als beslissing en werk verbonden zijn, kun je controleren of de implementatie echt de aanname test die ze moest testen.
4. Uitkomst
Een uitkomst is wat er gebeurde nadat het werk de gebruikers of het team bereikte. Het hoeft geen perfecte metric te zijn. Het kan een gemeten verandering zijn, een klantreactie, een mislukt experiment, een vertraagd resultaat of een uitdrukkelijk "we weten het nog niet".
Waar het om gaat, is dat het resultaat terugkeert naar de oorspronkelijke beslissing. Anders begint elke lancering een nieuw verhaal en mist het team de kans om zijn oordeelsvermogen te verbeteren.
Hoe verhoudt dit zich tot een opportunity solution tree?
Teresa Torres' opportunity solution tree, geïntroduceerd in 2016, koppelt een uitkomst aan opportunities, oplossingen en aannametests (Product Talk, 2023). De boom is het plan voor discovery. De graaf is het logboek van wat je onderweg koos en wat er daarna gebeurde. Ze passen bij elkaar: elke oplossing waar je je aan committeert wordt een beslissingsknoop, en elke aannametest wordt werk met een uitkomst eraan vast.
Hoe weet je dat het werkt? De test met de nieuwe collega
Of je productcontext bruikbaar is, kun je testen met één vraag:
Kan een nieuwe collega van een waargenomen signaal naar de resulterende beslissing, het werk dat die opleverde en het bewijs dat terugkwam, komen zonder iemand te vragen?
Als het antwoord nee is, is zoeken niet het probleem. De verbanden zijn nooit gelegd.
Een bruikbare graaf laat je in beide richtingen bewegen:
Van een klantsignaal naar de beslissingen die het beïnvloedde.
Van een beslissing terug naar het bewijs dat haar rechtvaardigde.
Van een beslissing naar de specificaties, experimenten en tickets die ze opleverde.
Van een uitkomst terug naar de oorspronkelijke aanname.
Van een strategieverklaring naar het huidige werk dat haar zogenaamd ondersteunt.
Daarom wint een graaf het van een map met samenvattingen. De waarde zit niet in de beschikbaarheid van elk item, maar in de zichtbare relatie tussen de items. Voor het datamodel hierachter, zie onze uitleg over kennisgrafen voor productmanagement.
Welke beslissingen verdienen een volledige vastlegging?
Niet elke keuze heeft vijf velden nodig. Jeff Bezos' aandeelhoudersbrief van 2016 scheidt omkeerbare "two-way door"-beslissingen, die een lichtgewicht proces kunnen volgen, van de rest. Hij betoogde ook dat de meeste beslissingen genomen moeten worden met ongeveer 70% van de informatie die je zou willen hebben (Amazon, 2017).
Een werkbare regel voor een klein team:
Volledige vastlegging voor beslissingen die duur zijn om terug te draaien: prijsstelling, datamodel, een nieuw klantsegment, een functie schrappen, alles wat meer dan twee weken bouwwerk kost.
Eén regel voor two-way doors: tekstaanpassingen, kleine UX-wijzigingen, interne tooling. Noteer de keuze en het signaal, sla de rest over.
Altijd de herzieningsvoorwaarde vastleggen als je beslist met onvolledige informatie. Als je beslist met 70% vertrouwen, schrijf dan op wat de ontbrekende 30% zou moeten laten zien om van gedachten te veranderen.
Kopieerbaar template voor een beslissingsvastlegging
Plak dit in de tool die je gebruikt. Elke regel tussen haakjes moet een link zijn, geen parafrase.
Beslissing: [één zin, specifiek genoeg om fout te kunnen zijn]
Vraag die ze beantwoordt: [de productvraag]
Eigenaar (goedkeurder): [één naam]
Bijdragers: [namen]
Datum van besluit:
Signalen: [links naar interviews, tickets, events]
Wat de signalen niet bewijzen: [één regel]
Overwogen alternatieven: [2-3 opties en waarom niet]
Aannames: [de overtuigingen die moeten kloppen]
Vertrouwen: [bijv. 60%]
Ontstaan werk: [links naar specificatie, tickets, experiment]
Verwachte uitkomst: [metric of gedrag, en uiterlijk wanneer]
Herzien als: [voorwaarde die de beslissing heropent]
Waargenomen uitkomst: [later invullen, met link]
De regel voor de eigenaar volgt Atlassians DACI-play, die staat op één goedkeurder naast de rollen Driver, Approver, Contributors en Informed; het is ontworpen voor 3 tot 6 mensen en duurt ongeveer 60 minuten (Atlassian). Eén genoemde goedkeurder maakt duidelijk wie je moet vragen als de herzieningsvoorwaarde afgaat.
Hoe voer je de workflow in de praktijk uit?
Begin met één echte productvraag, niet met een migratieproject.
Uitgewerkt voorbeeld (illustratief). Een AI-startup van vier mensen vraagt: "Moeten we investeren in het verkorten van de tijd van klantsignaal naar een bruikbare productbeslissing?"
Verzamel het bewijs. Breng de 6 interviewnotities, 14 supportberichten en de gebruikstrend bij elkaar die op de vraag slaan. Houd elke bron gelinkt. Een gesynthetiseerde uitspraak is geloofwaardiger als het team kan openen waar ze vandaan komt.
Leg de beslissing vast met een vertrouwensniveau. "Bouw een wekelijkse bewijs-digest voor de oprichter, 65% zeker dat hij de beslistijd verkort." Vertrouwen is een voorspelling om later mee te vergelijken, geen vertoning van zekerheid.
Koppel haar aan één klein stuk werk. Een prototype van twee weken, gestuurd naar 5 designpartners. Het werk moet de beslissing beter toetsbaar maken, niet alleen het team bezighouden.
Bepaal de terugweg vóór de oplevering. "Als de mediane tijd van signaal tot beslissing binnen 6 weken niet daalt van 12 dagen naar minder dan 7, herzien." Zet de controledatum in de agenda.
Sluit de lus. Zes weken later leg je vast wat er gebeurde en koppel je het aan de beslissing, ook als het antwoord "onduidelijk" is. Vergelijk over een kwartaal het uitgesproken vertrouwen met hoe vaak gokken uitpakten. Die vergelijking verbetert het oordeelsvermogen van het team.
De nuttige output is geen mooiere samenvatting. Het is een kortere weg van bewijs naar verantwoorde actie.
Wat verandert er voor een klein team?
Nieuwe collega's begrijpen niet alleen wat er wordt gebouwd, maar ook waarom het bestaat.
Oprichters stoppen met dezelfde contextvraag uit het hoofd te beantwoorden.
PM's besteden minder tijd aan het reconstrueren van de status en meer aan testen of het product richting de beoogde uitkomst beweegt.
Engineers en coding agents zien de beslissing achter een verzoek in plaats van een losse taak. Dat telt zwaarder naarmate meer tickets rechtstreeks naar een agent gaan; zie onze gids over AI coding agents productcontext geven.
Foute beslissingen worden lessen, geen schuldvraag. Een goede vastlegging beschermt de beslissing niet. Ze beschermt het denkproces doordat ze de aannames zichtbaar maakt.
Veelgemaakte fouten
Beslissingen vastleggen zonder signalen. Een logboek van conclusies zonder links naar bewijs is een archief van meningen.
De herzieningsvoorwaarde overslaan. Zonder die voorwaarde weet niemand wanneer een beslissing is verlopen.
AI-samenvattingen als bronnen behandelen. Een gegenereerd thema is een verwijzing naar bewijs, geen bewijs. Bewaar de ruwe links.
Vastleggingen achteraf schrijven. Gereconstrueerde redenering is een flatterende redenering. Schrijf de vastlegging op het moment dat je beslist.
Elke two-way door vastleggen. Als het template aanvoelt als bureaucratie, stoppen mensen ermee. Bewaar de volledige vastlegging voor dure keuzes.
De uitkomst nooit invullen. Een graaf met lege uitkomstvelden is een beslissingslogboek met extra stappen.
Waar Specky past
In Specky is dit de lus waaromheen het product is gebouwd: signalen uit gesprekken, feedback, Slack, Jira en analytics komen met hun bronnen in de Product Graph; het beslissingslogboek legt de keuze vast en citeert het bewijs erachter; specificaties en tickets dragen citaten in de tekst; en na de lancering kun je controleren of de gok werkte. Je team neemt de beslissing nog steeds zelf. De verbanden worden gelegd terwijl je werkt, in plaats van achteraf te worden gereconstrueerd.
Veelgestelde vragen
Wat is een beslissingsgraaf in productmanagement?
Het is een verbonden vastlegging van productkeuzes. Elke beslissing verwijst terug naar de signalen die haar informeerden (interviews, tickets, gebruiksdata) en vooruit naar het werk dat ze opleverde en de daarna gemeten uitkomst. In tegenstelling tot een plat beslissingslogboek laat het iedereen een opgeleverde functie herleiden naar het bewijs, of een klantklacht naar elke beslissing die ze beïnvloedde.
Hoe verschilt een beslissingsgraaf van een beslissingslogboek?
Een beslissingslogboek is een lijst met vermeldingen: wat is besloten, door wie, wanneer. Een graaf voegt links aan beide kanten van elke vermelding toe, naar het bewijs ervoor en naar het werk en de uitkomst erna. Het logboek vertelt wat er gebeurde. De graaf vertelt of de redenering standhield, en dat maakt latere beslissingen beter.
Wat is productgeheugen?
Productgeheugen is een informele naam voor de opgebouwde kennis van een team over waarom het product is zoals het is: het klantbewijs, de beslissingen, afwegingen en resultaten achter elke functie. Notities en documenten slaan stukjes ervan op. Het wordt pas bruikbaar als die stukjes zijn gekoppeld, zodat iemand nieuws de redenering kan volgen zonder de mensen te vragen die erbij waren.
Hoeveel tijd kost het koppelen van beslissingen?
Minder dan mensen vrezen. Een volledige vastlegging is een korte pagina tekst als het bewijs al is gelinkt, en de meeste two-way doors hebben genoeg aan één regel. De grotere kostenpost is de gewoonte om werk en uitkomsten terug te koppelen aan beslissingen. Teams die dat overslaan betalen later, met de meer dan 25% van de werkweek die Atlassian vond dat mensen kwijt zijn aan het zoeken naar informatie.
Hebben kleine teams dit echt nodig?
Kleine teams hebben het het meest nodig, omdat de context bij zeer weinig mensen zit. Met een mediane diensttijd van ongeveer 3 jaar voor jongere werknemers is degene die weet waarom een beslissing is genomen vaak binnen een paar productcycli vertrokken. Een pagina met gekoppelde beslissingen is goedkoper dan oude keuzes opnieuw bediscussiëren elke keer als er iemand nieuws bij komt.
GDPR-aligned. EU workspace data is stored in Frankfurt, Germany. GDPR and EU data Built in Vienna, Austria. A product of influence solutions fm GmbH (FN 675374y). Imprint 14-day trial. Card required, and nothing is charged until day 14. 30-day refund after subscribing. See pricing