2 juli 2026Bijgewerkt op Fathy Shalaby10 min leestijd
Learning velocity: waarom leersnelheid zwaarder weegt dan leversnelheid
AI maakte bouwen sneller. Het maakte niet sneller dat je weet wat je moet bouwen. Learning velocity, de snelheid van vraag naar een met bewijs onderbouwde beslissing, is het voordeel dat zich opstapelt.
Learning velocity is hoe snel een productteam een open vraag omzet in een beslissing die op bewijs steunt: van „we denken dat klanten X willen” naar „we hebben het getest, en dit gaan we doen”. Het telt zwaarder dan leversnelheid, omdat de meeste productideeën mislukken, en het team dat slechte ideeën het snelst laat vallen en goede het snelst bevestigt, bouwt zijn voorsprong steeds verder uit.
Belangrijkste inzichten
De meeste ideeën werken niet. Bij Microsoft verbeterde slechts ongeveer een derde van de ideeën die in gecontroleerde experimenten werden getest de metriek waarvoor ze bedoeld waren, en ongeveer een derde verslechterde die (Kohavi et al., 2009).
Bouwen werd sneller. In de gecontroleerde GitHub-studie uit 2022 onder 95 ontwikkelaars rondden Copilot-gebruikers een taak 55% sneller af (GitHub, 2022). Leren werd niet vanzelf sneller.
Deliverymetrieken stoppen bij de deployment. De change lead time van DORA loopt van commit tot productie (DORA); niets daarin meet of de wijziging werkte.
Bedrijven die veel leren, testen op volume: Booking.com draait zo’n 25.000 tests per jaar (HBR, 2020).
Je kunt het meten met vier getallen: leercyclustijd, beslissingen per maand, aandeel opgeleverde weddenschappen dat is beoordeeld, en wekelijkse klantcontactmomenten.
Wat is learning velocity?
Het is het tempo waarin een team gevalideerde beslissingen produceert: keuzes om iets te bouwen, te wijzigen of te stoppen, gebaseerd op bewijs dat daarvoor is verzameld. Het is de productversie van Eric Ries’ idee dat „de eenheid van vooruitgang voor Lean Startups gevalideerd leren is” (The Lean Startup). Ries stelt dat elk startupproces de Build-Measure-Learn-lus moet versnellen.
Twee dingen maken het anders dan leversnelheid:
Het telt beslissingen, geen releases. Een feature die is opgeleverd en nooit gemeten, levert nul leren op. Een test van twee dagen die een slecht idee de nek omdraait, levert veel op.
Het omvat het trage deel na de lancering. De lus is pas gesloten als iemand controleert of de weddenschap werkte en het plan bijstelt.
Leercyclustijd, gevalideerde beslissingen per maand
Klok start
Code is gecommit
Aanname is opgeschreven
Klok stopt
Wijziging is gedeployd
Beslissing genomen op basis van het resultaat
Faalpatroon
Trage, riskante releases
Snelle releases van dingen die niemand nodig had
Beide tellen. Maar een team kan topklasse zijn in delivery en toch langzaam leren; onze post over de illusie van productsnelheid gaat daar dieper op in.
Waarom is leersnelheid in 2026 een concurrentievoordeel?
Drie feiten komen samen.
1. De meeste ideeën mislukken, dus de snelheid waarmee je ze laat vallen telt. Kohavi’s team bij Microsoft vond dat slechts ongeveer een derde van de ideeën zijn doelmetriek verbeterde, een derde niets deed en ongeveer een derde ervoor schadelijk was (Kohavi et al., 2009). Ze merken op dat ook het succespercentage van Amazon onder de 50% lag. Als twee van de drie weddenschappen niets opleveren, wint het team dat dat in een week weet van het team dat dat in een kwartaal weet.
2. De winnaars zijn groot en moeilijk te voorspellen. Eén Bing-experiment, een wijziging in hoe advertentiekoppen werden getoond, verhoogde de omzet met 12%, goed voor meer dan $100 miljoen per jaar alleen in de VS (HBR, 2017). Het kostte maar een paar dagen engineering, maar bleef meer dan zes maanden ongebouwd liggen omdat het als lage prioriteit was gemarkeerd. Zulke winnaars vind je door meer ideeën te testen, niet door beter te gokken.
3. Bouwen is niet langer het knelpunt. Codeerassistenten verkortten de taaktijd in gecontroleerde studies sterk; in die van GitHub was het 1 uur 11 minuten met Copilot tegenover 2 uur 41 minuten zonder. Als bouwen goedkoper wordt, wordt het opleveren van niet-gevalideerde features ook goedkoper, en Pendo’s bevinding dat 80% van de features in het gemiddelde product zelden of nooit wordt gebruikt (Pendo, 2019) wordt makkelijker te herhalen. Schaars blijft: weten welke features het verdienen om te bestaan.
Concurrenten kunnen een feature in weken kopiëren. Ze kunnen niet het opgebouwde dossier kopiëren van wat jij hebt getest, wat je klanten deden en waarom je besloot wat je besloot.
Hoe meet je learning velocity?
Er bestaat geen standaardformule uit de sector. Dit zijn de vier metrieken die wij aanbevelen; samen zijn ze moeilijk te manipuleren.
Metriek
Definitie
Hoe te verzamelen
Gezonde richting
Leercyclustijd
Mediaan aantal dagen van een opgeschreven aanname tot een beslissing erover
Aannamelog of beslissingslog met twee datums
Omlaag
Gevalideerde beslissingen per maand
Beslissingen om te bouwen, te wijzigen of te stoppen die bewijs noemen dat voor die vraag is verzameld
Telling van beslissingslogregels met bewijs eraan gekoppeld
Omhoog
Beoordeelde opgeleverde weddenschappen
Aandeel lanceringen met een vastgelegd resultaat tegenover de doelmetriek binnen 6 weken
Lanceringslijst vergelijken met post-launchreviews
Omhoog, mik op 80%+
Klantcontactmomenten per week
Gesprekken, tests of observaties waarbij het team dat het product bouwt betrokken is
Agenda of researchlog
Minimaal 1, volgens Torres
De laatste komt van Teresa Torres, die continuous discovery definieert als wekelijkse contactmomenten met klanten door het team dat het product bouwt, gericht op een gewenst resultaat (Product Talk).
Uitgewerkt voorbeeld: wat drie keer sneller leren waard is (illustratief)
Stel dat een productteam van 5 mensen 3 gevalideerde beslissingen per maand neemt, met een mediane leercyclustijd van 41 dagen. Gebruik het basispercentage van Microsoft: ongeveer 1 op 3 geteste ideeën verbetert zijn doelmetriek.
Voor: 3 beslissingen × 1/3 succes = ongeveer 1 winnende wijziging per maand, dus 12 per jaar.
Na het terugbrengen van de cyclustijd naar 12 dagen met kleinere tests en een wekelijkse review: 9 beslissingen per maand × 1/3 = ongeveer 3 winnende wijzigingen per maand, dus 36 per jaar.
Het team stopt bovendien ongeveer 6 verliezende ideeën per maand eerder, voordat ze weken engineering opslokken.
De verhouding is waar het om draait: het team is niet beter in gokken dan eerst. Het komt drie keer sneller achter de waarheid.
Hoe help je een productteam sneller te leren? Een methode in 7 stappen
Schrijf de vraag op vóór de oplossing. Leg voor elke weddenschap de aanname vast, de beslissing die ze voedt en de metriek die haar zou beslechten. Een ongeteste aanname zonder beslissing erbij is slechts een mening.
Kies de goedkoopste test die je van mening kan doen veranderen. Interviews, fake doors, concierge-tests en prototypes beantwoorden vaak in dagen wat een volledige build in maanden beantwoordt. Onze gids over het kiezen van een productexperiment koppelt 55 methoden aan de vraag die je beantwoord wilt hebben.
Stel de beslisregel vooraf vast. „Als minder dan 15% van de proefgebruikers in 2 weken op de importknop klikt, laten we het vallen.” Vooraf vastleggen voorkomt dat resultaten achteraf worden herinterpreteerd zodat ze bij het plan passen.
Praat elke week met klanten. Torres’ wekelijkse ritme zorgt voor een gestage stroom bewijs, zodat tests uitgaan van echte problemen. Onze post over continuous discovery laat zien hoe je dat inplant zonder dat het de roadmap overneemt.
Ga snel bij omkeerbare beslissingen. Jeff Bezos stelt dat de meeste beslissingen genomen moeten worden met ongeveer 70% van de informatie die je zou willen hebben, en noemt omkeerbare beslissingen tweerichtingsdeuren die een licht proces verdienen (Amazon, 2017). Zijn doel: „beslissingen van hoge kwaliteit en met hoge snelheid”. Bewaar trage, zware beoordeling voor beslissingen die je niet kunt terugdraaien.
Sluit de lus na de lancering. Plan de review in op het moment dat je oplevert: controleer de doelmetriek na 2 en 6 weken, leg het resultaat vast en besluit of je het behoudt, itereert of verwijdert.
Maak leren gedeeld. Schrijf elke beslissing, het bewijs en het resultaat in een productbeslissingslog. Leren in het hoofd van één persoon stapelt niet op als die persoon vertrekt of het vergeet.
Wat remt het leren van een productteam?
De meeste teams zijn traag om structurele redenen, niet door gebrek aan inspanning:
Grote batches. Een project van een kwartaal levert één antwoord per kwartaal op. Opdelen in 3-4 testbare plakken levert 3-4 antwoorden op.
Roadmaps die features op datum beloven. Een feature met een datum wordt een verplichting, dus bewijs ertegen wordt genegeerd. Een resultaatgerichte roadmap houdt het resultaat vast en laat de weddenschappen veranderen.
Geen afgesproken succesmetriek. Als niemand heeft afgesproken wat „het werkte” betekent, is elk resultaat bespreekbaar. Een duidelijke north star met inputmetrieken regelt dat vooraf.
Bewijs verspreid over tools. Interviews op de ene plek, tickets op een andere en analytics op een derde betekent dat elke beslissing begint met een archeologisch project.
Geen strategie om tegen te testen. Zonder een uitgesproken weddenschap zijn tests willekeurig. Een strategiecanvas van één pagina benoemt de riskantste aannames die je het eerst moet testen.
Veelgemaakte fouten en grenzen
Experimenten tellen in plaats van beslissingen. Een team dat 40 tests per maand draait en niets verandert, heeft activiteit, geen leren. Volg de beslissingen die op resultaten zijn genomen.
Snelheid zonder zorgvuldigheid. Kohavi’s paper waarschuwt tegen sequentiële, ongecontroleerde experimenten, zoals deze week vergelijken met vorige week in plaats van tegelijkertijd een controlegroep te draaien, omdat ze heel vaak misleiden. Snel en fout is erger dan langzaam en goed.
Denken dat je A/B-tests nodig hebt. Gecontroleerde experimenten hebben verkeer nodig. Een product met 200 wekelijkse gebruikers kan kleine effecten niet detecteren. Onder die schaal komt snel leren van interviews, usabilitytests, fake doors en concierge-aanbiedingen, niet van statistiek.
Leertheater. Onderzoek dat nooit een beslissing verandert, is theater. Als de laatste 10 onderzoeken niets aan de roadmap veranderden, vraag je dan af of de roadmap al vaststond.
Onomkeerbare beslissingen negeren. Prijswijzigingen, datamigraties en publieke toezeggingen zijn eenrichtingsdeuren. Ze verdienen de trage route, zelfs in een team dat snel leert.
Waar Specky past
De langzaamste delen van de lus zijn meestal het verzamelen van bewijs en het sluiten van de lus na de lancering, en daar helpt Specky. Het leest klantgesprekken, feedback, Slack, Jira en analytics in een Product Graph in, zodat een nieuwe vraag begint bij wat je al weet. Alex, de AI-researchagent, voert klantinterviews uit via een deelbare link, zodat research niet op agenda’s hoeft te wachten. Na een lancering controleert het of de weddenschap zijn doel heeft verschoven, en het Decision Log bewaart het dossier. Voor grotere organisaties maakt dezelfde lus over veel squads deel uit van het productoperatiemodel voor groeiende teams.
Veelgestelde vragen
Wat is learning velocity in productmanagement?
Learning velocity is de snelheid waarmee een productteam aannames omzet in beslissingen die op bewijs steunen. Het wordt gemeten vanaf het moment dat een vraag wordt opgeschreven tot het moment dat op basis van het resultaat een beslissing wordt genomen om te bouwen, te wijzigen of te stoppen. Het verschilt van delivery velocity, die meet hoe snel code in productie komt, ongeacht of die werkt.
Hoe meet je learning velocity?
Volg vier getallen: de mediane leercyclustijd (dagen van aanname tot beslissing), gevalideerde beslissingen per maand, het aandeel opgeleverde weddenschappen dat binnen ongeveer 6 weken is beoordeeld tegen de doelmetriek, en klantcontactmomenten per week. Gebruik ze samen, want elk afzonderlijk is te manipuleren, bijvoorbeeld door veel triviale experimenten te draaien.
Is leersnelheid hetzelfde als experimentsnelheid?
Nee. Experimentsnelheid telt uitgevoerde tests; leersnelheid telt beslissingen die door bewijs zijn veranderd of bevestigd. Een team kan veel experimenten draaien en weinig leren als de tests triviaal zijn of de resultaten de roadmap nooit raken. Experimentsnelheid is een nuttige input, maar de output die telt, is dat betere beslissingen eerder worden genomen.
Kan een kleine startup sneller leren zonder A/B-tests?
Ja. Het meeste leren in een vroege fase komt van kwalitatieve methoden en methoden voor weinig verkeer: klantinterviews, usabilitytests, fake-doortests, concierge-aanbiedingen en prijsgesprekken. Daarmee beantwoord je een vraag in 2-10 dagen. A/B-tests worden pas nuttig als je genoeg verkeer hebt om de effectgroottes te detecteren waar je om geeft, wat de meeste producten met minder dan een paar duizend wekelijkse gebruikers niet hebben.
Waarom telt leersnelheid zwaarder nu AI code schrijft?
Omdat AI de kosten van bouwen verlaagt, maar niet de kosten van het verkeerde bouwen. De GitHub-studie uit 2022 vond dat ontwikkelaars een taak 55% sneller afrondden met Copilot. Als features goedkoop te bouwen zijn, wordt de schaarse vaardigheid weten welke je moet bouwen, en het team dat ideeën het snelst valideert, verspilt het minst van zijn nieuwe capaciteit.
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