Vaste pipelines versus adaptieve decompositie
Prompt chaining voor bekende stappen; adaptief voor open opdrachten
Vaste pipelines versus adaptieve decompositie is een gratis Claude Architect-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.
Twee manieren om werk op te splitsen
Wanneer een taak te groot is voor één prompt, splits je die op. Er zijn twee fundamentele strategieën, en de juiste kiezen is een belangrijke architectuurvaardigheid.
- Vaste pijplijn (promptketen): je legt een bekende reeks stappen hard vast. Stap 1 levert input aan stap 2, die input levert aan stap 3.
- Adaptieve opsplitsing: het model bepaalt wat het vervolgens moet doen op basis van wat het ontdekt en blijft dit herhalen totdat het doel is bereikt.
Vuistregel: vaste pijplijnen voor bekende opeenvolgende stappen; adaptief voor onderzoeken zonder vast eindpad. Deze les maakt die keuze precies.
Vaste pijplijn = promptketen
Een vaste pijplijn is simpelweg een promptketen: je orkestreert een deterministische reeks in je eigen code. Je kent de stappen vooraf, dus je koppelt ze expliciet aan elkaar. Elke aanroep voert één gerichte taak uit en de uitvoer ervan wordt de input voor de volgende aanroep.
Omdat je de volgorde beheert, is de stroom voorspelbaar, eenvoudig te debuggen en gemakkelijk te begrijpen qua kosten en werking. Er is geen door het model aangestuurde vertakking over wat vervolgens moet gebeuren — alleen het werk binnen elke stap.
# Fixed pipeline: extract -> classify -> summarize
from anthropic import Anthropic
client = Anthropic()
def step(system, user):
r = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
system=system,
messages=[{"role": "user", "content": user}],
)
return r.content[0].text
entities = step("Extract entities as JSON.", document)
category = step("Classify this record.", entities)
summary = step("Write a one-line summary.", category)Wanneer een vaste pijplijn de beste keuze is
Kies een vaste pijplijn wanneer het werk een stabiele, bekende vorm heeft:
- De stappen zijn bij elke uitvoering hetzelfde (extraheren, daarna valideren, daarna formatteren).
- De volgorde is belangrijk en verandert zelden.
- Je wilt voorspelbare kosten en latentie, en eenvoudig debuggen.
- Elke fase heeft een duidelijke, beperkte verantwoordelijkheid.
Klassiek voorbeeld: gestructureerde gegevensextractie. Extraheer velden, voer daarna een validatie- en nieuwe poging uit en voeg vervolgens herkomstgegevens toe. Je doet deze drie dingen altijd in die volgorde — dus koppel ze aan elkaar.
Adaptieve opsplitsing = modelgestuurd
Bij adaptieve opsplitsing laat je de planning aan het model over. Je geeft het tools en een doel; het inspecteert resultaten en kiest de volgende actie. Dit is de agentische lus: stuur een aanvraag, inspecteer stop_reason en voer, als dit tool_use is, de tools uit, voeg de resultaten toe aan de geschiedenis en herhaal dit totdat end_turn wordt bereikt.
Je kunt het pad niet vooraf vastleggen, omdat je het niet van tevoren kent — het hangt af van wat elke stap aan het licht brengt.
# Adaptive: the model decides which tool to call next
while True:
resp = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
tools=tools,
messages=messages,
)
if resp.stop_reason == "tool_use":
results = run_tools(resp) # execute requested tools
messages.append({"role": "assistant", "content": resp.content})
messages.append({"role": "user", "content": results})
continue
break # terminate on stop_reason, never by parsing textWanneer adaptieve opsplitsing de beste keuze is
Kies adaptieve opsplitsing voor onderzoeken zonder vast eindpad waarvan je het verloop niet vooraf kunt kennen:
- Debuggen op basis van een vaag symptoom — je gebruikt grep, leest en zoekt vervolgens opnieuw naar toepassingen op basis van wat je vindt.
- Onderzoek met meerdere bronnen waarbij vervolgqueries afhangen van eerdere antwoorden.
- Klantenondersteuning waarbij de volgende actie afhangt van wat een opzoeking oplevert.
Hier is de vertakking het werk. Een rigide pijplijn zou paden missen of uitgroeien tot onbeheerbare voorwaardelijke logica.
Beëindig op stop_reason, niet op tekst
De meest voorkomende fout in een adaptieve lus op het examen: de lus beëindigen door de tekst van het model te doorzoeken op woorden als "klaar" of "afgerond". Doe dat niet. Beslissingen worden door het model gestuurd; beëindig op de API-waarde stop_reason.
De lus eindigt wanneer stop_reason gelijk is aan end_turn. Zolang dit tool_use is, ga je door. Een iteratielimiet is alleen een veiligheidsnet — nooit het primaire mechanisme om te stoppen. Gebruik hardgecodeerde besturing voor garanties, niet om te bepalen wanneer het werk inhoudelijk voltooid is.
# WRONG: parsing text for completion
if "done" in resp.content[0].text.lower():
break
# RIGHT: drive on stop_reason; cap is only a safety net
MAX_STEPS = 25
for _ in range(MAX_STEPS):
resp = client.messages.create(...)
if resp.stop_reason != "tool_use":
break # end_turn / max_tokens / stop_sequenceHybride: pijplijnen met adaptieve fasen
Echte systemen combineren beide. De buitenste stroom is vaak een vaste pipeline, maar één stap kan een adaptieve agentische lus zijn. Zo krijg je de voorspelbaarheid van ketens op macroniveau en flexibiliteit waar je die echt nodig hebt.
Voorbeeld: een extractiepipeline waarvan de middelste stap een adaptieve agent is die onduidelijkheden oplost en een onbekend aantal keer opzoektools kan aanroepen — ingesloten tussen een deterministische validatie- en formatteringsstap ervoor en erna.
# Outer = fixed chain; one stage = adaptive loop
raw = extract_stage(document) # fixed
resolved = adaptive_resolver(raw) # agentic loop inside
final = validate_and_format(resolved) # fixedCode review in meerdere rondes: een keuze voor decompositie
Decompositie gaat niet alleen over pipelines versus lussen — het gaat ook over hoe je een taak opsplitst om de aandacht van het model te beschermen. Code review van meerdere bestanden is het klassieke voorbeeld.
Een enkele ronde over veel bestanden verspreidt de aandacht en mist zowel lokale fouten als integratieproblemen. De oplossing is een weloverwogen decompositie: eerst een lokale ronde per bestand, daarna een afzonderlijke integratieronde voor meerdere bestanden. Twee gerichte rondes zijn beter dan één ongerichte ronde.
# Decompose review into focused passes
for f in changed_files:
review_local(f) # pass 1: per-file, focused
review_cross_file(changed_files) # pass 2: integration concernsCoördinatoren decomponeren adaptief
In een multi-agentsysteem met hub-en-spaken decomposeert de coördinator het doel, delegeert hij taken aan subagents en voegt hij de resultaten samen. Dit is adaptieve decompositie op de orkestratielaag — de coördinator bepaalt op basis van het verzoek hoe de taak wordt opgesplitst.
Belangrijk: subagents erven de gespreksgeschiedenis van de coördinator niet. Elke prompt voor een subagent moet de volledige context expliciet bevatten. Meerdere aanroepen van Task in één antwoord worden parallel uitgevoerd — handig wanneer deelproblemen onafhankelijk zijn.
# Coordinator delegates with explicit, self-contained context
subagent_prompt = f"""You are researching ONE sub-topic.
Context (do not assume shared history):
Goal: {goal}
Sub-topic: {subtopic}
Constraints: {constraints}
Return findings with source citations."""Sessies: hervatten, forken of opnieuw beginnen
Adaptief werk strekt zich vaak uit over meerdere sessies. Claude Code geeft je --resume <name> om een benoemde sessie voort te zetten en fork_session om vanaf een gedeeld punt een vertakking te maken en alternatieven parallel te verkennen.
Let wel op: hervatte toolresultaten kunnen verouderd zijn als de codebase intussen is gewijzigd. Soms is een nieuwe sessie met een gestructureerde samenvatting beter dan hervatten — je krijgt de actuele toestand plus de samengevatte context, zonder verouderde tooluitvoer mee te slepen.
# Continue a named session
claude --resume refactor-auth
# Branch to explore an alternative path
# fork_session creates a sibling from the shared point
# When code moved on, prefer a fresh session + summary
claude -p "Here is a structured summary of prior work: ..."Een beslischecklist
Vraag jezelf voordat je begint af:
- Ken ik de stappen vooraf, in een vaste volgorde? -> vaste pipeline / promptketen.
- Hangt de volgende stap af van wat eerdere stappen onthullen? -> adaptieve agentische lus.
- Is het grotendeels vast met één onzekere stap? -> hybride: keten de buitenste stroom en sluit een adaptieve lus in.
- Beoordeel je veel bestanden? -> splits op in rondes per bestand en daarna rondes voor meerdere bestanden.
En altijd: beëindig adaptieve lussen op stop_reason, waarbij een maximumaantal iteraties alleen als vangnet dient.
Korte controle
Een beslissing op basis van een scenario over het kiezen van een decompositestrategie.
Samenvatting
Belangrijkste punten:
- Vaste pipeline (promptketen) voor bekende stappen in een vaste volgorde — voorspelbaar, goed te debuggen en goedkoop.
- Adaptieve decompositie voor open onderzoeken waarbij de volgende stap afhangt van wat je ontdekt.
- Hybride komt vaak voor: een vaste buitenste stroom met een ingesloten adaptieve stap.
- Beëindig adaptieve lussen altijd op
stop_reason(end_turn); een maximumaantal iteraties is een vangnet, nooit de primaire stop. Parse nooit tekst om te bepalen of iets "done" is. - Splits een review van meerdere bestanden op in een ronde per bestand en daarna een afzonderlijke ronde voor meerdere bestanden.
- Subagents erven de geschiedenis niet — geef de context expliciet door. Hervat sessies voorzichtig; een nieuwe sessie met een gestructureerde samenvatting kan beter zijn dan verouderde resultaten van hervatte tools.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 26
- Lessen
- 104
Veelgestelde vragen
Is de les “Vaste pipelines versus adaptieve decompositie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Vaste pipelines versus adaptieve decompositie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.
Wat leer ik in “Vaste pipelines versus adaptieve decompositie”?
Prompt chaining voor bekende stappen; adaptief voor open opdrachten Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Claude Architect te beginnen?
Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Vaste pipelines versus adaptieve decompositie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Claude Architect?
Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Vaste pipelines versus adaptieve decompositie
- Decompositie in meerdere passes
- Sessiebeheer
- Verouderde context en opnieuw beginnen