De eerste versie van je AI workflow is bijna altijd een blok: een prompt die alles tegelijk moet doen. Zolang de taak klein is, werkt dat prima.
Maar elke keer dat je het resultaat aanscherpt, groeit dat blok. Er komt een instructie bij, dan een uitzondering, dan nog een “o ja, en let ook hierop”. Voor je het weet is het een black box die niemand meer kan volgen, en bij een fout weet je niet eens waar het misgaat.
De oplossing is geen nog slimmere mega-prompt. De oplossing is opsplitsen. Een AI workflow die je wilt blijven doorontwikkelen, knip je op in losse stappen die elk een deeltaak doen, met een heldere input en een voorspelbare output. Zo kun je elke stap apart testen, vervangen en hergebruiken. Die aanpak heet prompt chaining.
Prompt chaining is het verschil tussen een flow die je na drie maanden nog begrijpt en een flow die je opnieuw vanaf nul moet bouwen. In deze gids ontleed ik de zes bouwstenen van een goede AI workflow: een heldere trigger, een deeltaak per stap, expliciete in- en output, observeerbaarheid, controlepunten en een schone afronding.
Dit stuk is praktisch bedoeld. Bouw je zelf flows in een tool als n8n, Make of een eigen scriptomgeving, dan kun je elke bouwsteen direct toepassen op een flow die nu nog een groot blok is.
Waarom een groot prompt-blok altijd vastloopt
Een groot prompt-blok loopt vast omdat het twee dingen tegelijk moet zijn: volledig en overzichtelijk. Die twee vechten met elkaar. Hoe meer je een AI workflow doorontwikkelt, hoe meer randgevallen je toevoegt, en hoe langer en voller het blok wordt. Op een gegeven moment raakt het model verstrikt in zijn eigen instructies.
Neem een flow die ik vaak tegenkom: berichten uit een contactformulier verwerken. De flows die ik het vaakst heb moeten opknippen, begonnen precies zo.
In de eerste versie vat hij een bericht samen en schrijft een concept-antwoord. Prima. Dan wil je er urgentie-inschatting bij. Daarna moet hij spam herkennen. Daarna een andere toon voor bestaande klanten dan voor nieuwe leads. Daarna een uitzondering voor facturen. Elke toevoeging is logisch, maar samen maken ze van een heldere taak een onleesbaar geheel.
Het patroon is voorspelbaar. Naarmate de eisen groeien, gebeuren er drie dingen tegelijk. De output wordt instabiel, omdat het model bij elke run andere instructies zwaarder weegt. Het debuggen wordt onmogelijk, want bij een fout zie je alleen het eindresultaat en niet welke deeltaak struikelde. En je raakt vastgeklonken aan een specifiek model, omdat het blok precies op de quirks van dat ene model is afgesteld.
Een opgesplitste AI workflow draait die dynamiek om. Elke stap doet een ding, dus je test elke stap apart, je vervangt een zwakke stap zonder de rest te slopen, en je hergebruikt sterke stappen in andere flows. De winst zit niet in een veel beter eindresultaat op dag een. De winst zit in onderhoudbaarheid: een flow die je een halfjaar later nog durft aan te raken.
De anatomie van een goede AI workflow: zes bouwstenen
Een goede AI workflow heeft zes herkenbare bouwstenen die je in vrijwel elke betrouwbare flow terugziet. Samen vormen ze de anatomie: van het signaal dat de flow start tot de afronding die hem netjes overdraagt. Loop ze langs als een checklist voor je eigen flows.
1. Een heldere trigger
De trigger is het signaal dat de flow start, en hij moet precies een gebeurtenis vertegenwoordigen. Een nieuw bericht, een nieuwe rij in een sheet, een afgerond formulier, een tijdstip. Een scherpe trigger voorkomt dat een flow op het verkeerde moment of op de verkeerde data draait.
Vage triggers (“draai elk uur en kijk of er iets te doen is”) zijn de eerste bron van ruis. Hoe specifieker het startsignaal, hoe minder je flow verderop hoeft te corrigeren.
2. Een deeltaak per stap
Dit is de kern van prompt chaining: elke stap doet een ding en geeft het door. Samenvatten is een stap. Classificeren is een stap. Een antwoord schrijven is een stap. Door taken te scheiden geef je het model per stap een schone, korte opdracht in plaats van een overvolle.
Het bijkomende voordeel is dat je niet voor elke stap hetzelfde zware model nodig hebt: een simpele classificatie kan op een klein, goedkoop model, terwijl je het sterke model bewaart voor de stap die er echt toe doet.
3. Expliciete in- en output
Elke stap heeft een afgesproken input en een voorspelbare output, het liefst in een vast formaat zoals JSON. Dat formaat is het contract tussen je stappen. Stap twee mag erop rekenen dat stap een een veld urgentie oplevert met de waarde hoog, midden of laag. Zonder die contracten moet elke stap raden wat de vorige bedoelde, en stapelen de fouten zich op. Met die contracten kun je een stap vervangen zolang hij hetzelfde formaat teruggeeft.
4. Observeerbaarheid per stap
Observeerbaarheid betekent dat je per stap kunt zien wat erin ging en wat eruit kwam. Dit is precies wat een groot blok je afpakt. In een opgesplitste AI workflow log je de in- en output van elke stap, zodat je bij een fout direct naar de stap springt die struikelde in plaats van het hele blok te herlezen.
Een flow die je niet kunt observeren, kun je niet gericht verbeteren: je gokt naar de oorzaak in plaats van hem aan te wijzen.
5. Controlepunten en guardrails
Een controlepunt is een stap die de output toetst voordat de flow verdergaat. Voldoet de samenvatting aan het verwachte formaat? Valt de score binnen het toegestane bereik? Bij twijfel stopt de flow of vraagt hij om een handmatige controle. Die guardrails houden fouten klein en lokaal in plaats van dat ze door de hele keten doorrollen.
Voor alles wat naar buiten gaat, zoals een klant-antwoord of een publicatie, geef ik zelf altijd het laatste akkoord tussen de stappen, tot ik de flow vertrouw.
6. Een schone afronding
De laatste bouwsteen is de overdracht: de flow levert zijn resultaat af op een vaste plek, in een vast formaat, klaar voor de volgende stap of voor jouw controle. Een concept in de juiste map, een rij in een sheet, een melding in het juiste kanaal.
Een schone afronding maakt van je flow een herbruikbaar onderdeel: de output van de ene flow wordt moeiteloos de input van de volgende. Zo bouw je geen losse oplossingen, maar onderdelen die op elkaar aansluiten.
Laat sensoren je flow voeden in plaats van een vaste planning
Een sensor is een kleine, zelfstandige stap die een toestand controleert en daar een signaal van maakt. In plaats van een logge flow die elk uur alles nakijkt, bouw je losse sensoren die elk een ding bewaken en pas een vervolgstap starten als er echt iets verandert.
Een sensor checkt of een voorraad onder een grens zakt, of een pagina een foutcode teruggeeft, of een nieuwe review binnenkomt. Het signaal dat eruit komt, is de input voor de rest van de keten.
Dit is hetzelfde anatomie-principe, maar dan toegepast op de trigger-kant. Een sensor doet een ding, levert een schoon signaal en is apart te testen. Daardoor reageert je systeem op wat er gebeurt in plaats van blind een schema af te werken.
Je krijgt minder ruis, minder onnodige runs en een flow die je per signaal kunt aan- en uitzetten zonder het geheel te raken. Wie zijn AI workflow signaal-gedreven opbouwt, ruilt een onhandelbaar mega-script in voor losse sensoren die elk een ding bewaken.
Zo splits je een bestaande AI workflow op in stappen
Een bestaand blok opsplitsen is geen herbouw vanaf nul, maar een gerichte ontleding. Werk in deze volgorde, dan houd je de flow werkend terwijl je hem uit elkaar haalt.
Stap 1. Schrijf op wat het blok feitelijk doet. Lijst elke deeltaak die in de mega-prompt verstopt zit. Samenvatten, classificeren, beslissen, formuleren: meestal vind je er vier tot zeven. Dit lijstje is je nieuwe stappenplan.
Stap 2. Bepaal het contract tussen de stappen. Leg per stap vast welke input hij krijgt en welke output hij teruggeeft. Kies een vast formaat en houd je eraan. Aan dit stuk heb je later het meeste, want het maakt debuggen achteraf simpel.
Stap 3. Knip de stappen los en test ze apart. Bouw elke deeltaak als losse stap met een korte, scherpe prompt. Test elke stap met een paar voorbeelden voordat je ze aan elkaar koppelt. Een stap die los werkt, werkt straks ook in de keten.
Stap 4. Voeg controlepunten en logging toe. Zet tussen de stappen toetsen op het formaat en log de in- en output. Vanaf nu zie je waar het misgaat in plaats van dat je het raadt.
Stap 5. Zet het geheel achter elkaar en houd een laatste controle handmatig. Koppel de stappen, laat de flow draaien op echte data en geef zelf het laatste akkoord tot de uitkomst stabiel is. Pas als een flow drie keer op rij klopt, haal ik die handmatige controle eruit.
Het lastige van deze aanpak zit aan de voorkant: stappen en contracten inrichten kost meer tijd dan een prompt overtypen. Dat input-werk is groter dan het output-werk. Maar juist die voorkant levert je een AI workflow op die meegroeit in plaats van vastloopt.
Veelgestelde vragen over een AI workflow bouwen
Wat is prompt chaining?
Prompt chaining is het opsplitsen van een AI-taak in losse stappen die elk een deeltaak afhandelen en hun output doorgeven aan de volgende stap. In plaats van een grote prompt die alles tegelijk doet, krijg je een keten van kleine, geteste stappen. Het maakt een AI workflow stabieler, makkelijker te debuggen en minder afhankelijk van een specifiek model.
Hoe bouw je een AI workflow?
Je bouwt een AI workflow door eerst de deeltaken te benoemen, daarna per stap een input- en outputformaat af te spreken, en vervolgens elke stap los te bouwen en te testen voordat je ze koppelt. Voeg controlepunten en logging toe en geef zelf het laatste akkoord tot de flow betrouwbaar draait. Begin klein en breid pas uit als de basis stabiel is.
Waarom zou je een AI-taak opsplitsen in stappen?
Opsplitsen lost de drie problemen op die een groot prompt-blok veroorzaakt: instabiele output, onmogelijk debuggen en vastzitten aan een model. Met losse stappen test je elke deeltaak apart, vervang je een zwakke stap zonder de rest te raken en hergebruik je sterke stappen elders. De prijs is meer inrichtwerk vooraf, de opbrengst is onderhoudbaarheid.
Hoeveel stappen heeft een goede AI workflow?
Er is geen vast aantal, maar de meeste praktische flows komen uit op vier tot zeven stappen. Het juiste aantal volgt uit de deeltaken, niet uit een streefgetal: elke stap hoort een duidelijk afgebakende taak te hebben. Te weinig stappen levert opnieuw een blok op, te veel stappen maakt de keten nodeloos complex.
Heb je code nodig om een AI workflow te bouwen?
Nee. In tools als n8n of Make bouw je een AI workflow visueel, met stappen die je aan elkaar koppelt zonder te programmeren. Het denkwerk zit niet in de code maar in de architectuur: de deeltaken benoemen, contracten afspreken en controlepunten plaatsen. Die principes gelden of je nu klikt of programmeert.
Een AI workflow die je kunt blijven doorontwikkelen, is geen kwestie van de slimste prompt maar van de juiste anatomie: kleine stappen, heldere contracten en zicht op elke schakel. Heb je een flow die te groot is geworden, stuur me dan je opzet, dan kijk ik waar je hem kunt opknippen. Lees eerst hoe ik AI-automatisering voor het MKB aanpak.
Verder lezen in dit AI-automatisering cluster
- AI automatisering voor MKB: workflows die tijd besparen
- AI content workflow: het 7-stappenplan in de praktijk
- n8n vs Make vs Zapier: welke automatiseringstool past bij jou
- Context engineering: waarom AI zonder context vastloopt
Externe bronnen en onderzoek
Voor de techniek achter prompt chaining zijn dit twee bruikbare startpunten.
Anthropic beschrijft hoe je complexe prompts opknipt in een keten van stappen voor stabielere output. Lees verder: Chain complex prompts (Claude docs).
IBM legt het concept en de toepassingen van prompt chaining toegankelijk uit. Lees verder: What is prompt chaining (IBM).
