Claude Architect · Lektion

Faste pipelines vs. adaptiv nedbrydning

Prompt chaining til kendte trin; adaptiv nedbrydning til åbne opgaver

Lektion 1 af 413 trin

Faste pipelines vs. adaptiv nedbrydning er en gratis Claude Architect-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Claude Architect, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Claude Architect-kurset indeholder 4 lektioner i alt.

To måder at opdele arbejde på

Når en opgave er for stor til en enkelt prompt, opdeler du den. Der er to grundlæggende strategier, og det er en central arkitekturfærdighed at vælge den rigtige.

Fast pipeline (promptkædning): du hardcoder en kendt rækkefølge af trin. Trin 1 leverer input til trin 2, som leverer input til trin 3.
Adaptiv opdeling: modellen beslutter, hvad der skal ske derefter, ud fra det, den opdager, og gentager processen, indtil målet er nået.

Tommelfingerreglen er: faste pipelines til kendte sekventielle trin; adaptiv opdeling til åbne undersøgelser. Denne lektion gør beslutningen præcis.

Fast pipeline = promptkædning

En fast pipeline er ganske enkelt promptkædning: du orkestrerer en deterministisk rækkefølge i din egen kode. Du kender trinnene på forhånd, så du kobler dem eksplicit sammen. Hvert kald udfører én fokuseret opgave, og dets output bliver input til det næste kald.

Fordi du styrer rækkefølgen, er forløbet forudsigeligt, nemt at fejlfinde og billigt at analysere. Der er ingen modelstyret forgrening om, hvad der skal ske derefter — kun arbejdet i hvert trin.

# 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)

Hvornår en fast pipeline er bedst

Vælg en fast pipeline, når arbejdet har en stabil, kendt form:

Trinnene er de samme ved hver kørsel (udtræk, derefter validering, derefter formatering).
Rækkefølgen er vigtig og ændrer sig sjældent.
Du ønsker forudsigelige omkostninger, svartider og nem fejlretning.
Hver fase har et klart og afgrænset ansvar.

Et klassisk eksempel er udtræk af strukturerede data. Udtræk felterne, kør derefter en validerings-/gentagelsesrunde, og tilføj til sidst oprindelsesoplysninger. Du udfører altid de tre ting i den rækkefølge — så kæd dem sammen.

Adaptiv opdeling = modelstyret

Adaptiv opdeling overlader planlægningen til modellen. Du giver den værktøjer og et mål; den undersøger resultaterne og vælger den næste handling. Det er agentløkken: send en forespørgsel, undersøg stop_reason, og hvis den er tool_use, så kør værktøjerne, føj resultaterne til historikken, og gentag, indtil end_turn.

Du kan ikke på forhånd fastlægge forløbet, fordi du ikke kender det på forhånd — det afhænger af, hvad hvert trin afslører.

# 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 text

Hvornår adaptiv opdeling er bedst

Vælg adaptiv opdeling til åbne undersøgelser, hvor forløbet ikke kan kendes på forhånd:

Fejlfinding ud fra et upræcist symptom — du bruger grep, læser og søger derefter efter anvendelser baseret på det, du finder.
Undersøgelser på tværs af flere kilder, hvor opfølgende forespørgsler afhænger af tidligere svar.
Kundesupport, hvor den næste handling afhænger af, hvad et opslag returnerer.

Her ER forgreningen selve arbejdet. En stiv pipeline ville enten overse forløb eller eksplodere i betingelser, der ikke kan vedligeholdes.

Afslut på stop_reason, ikke på tekst

Den mest almindelige fejl i den adaptive løkke ved eksamen er at afslutte løkken ved at lede i modellens tekst efter ord som "færdig" eller "afsluttet". Lad være. Beslutningerne er modelstyrede; afslut på API'ets stop_reason.

Løkken slutter, når stop_reason er end_turn. Mens den er tool_use, fortsætter du. En grænse for antal iterationer er kun et sikkerhedsnet — aldrig den primære måde at stoppe på. Brug hardkodet styring til garantier, ikke til at afgøre, hvornår arbejdet begrebsmæssigt er færdigt.

# 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_sequence

Hybrid: Pipelines med adaptive faser

Virkelige systemer kombinerer begge dele. Det ydre flow er ofte en fast pipeline, men ét trin kan være en adaptiv agentbaseret løkke. Du får forudsigeligheden ved kædning på makroniveau og fleksibilitet dér, hvor du faktisk har brug for den.

Eksempel: en ekstraktionspipeline, hvor det midterste trin er en adaptiv agent, der "løser uklarheder" og kan kalde opslagværktøjer et ukendt antal gange — omgivet af et deterministisk validerings- og formateringstrin før og efter.

# Outer = fixed chain; one stage = adaptive loop
raw      = extract_stage(document)        # fixed
resolved = adaptive_resolver(raw)         # agentic loop inside
final    = validate_and_format(resolved)  # fixed

Kodegennemgang i flere gennemløb: Et valg af opdeling

Opdeling handler ikke kun om pipelines kontra løkker — det handler også om, hvordan du deler en opgave op for at beskytte modellens opmærksomhed. Gennemgang af kode i flere filer er det klassiske eksempel.

Et enkelt gennemløb af mange filer spreder opmærksomheden og overser både lokale fejl og integrationsproblemer. Løsningen er en bevidst opdeling: først et lokalt gennemløb pr. fil, derefter et separat integrationsgennemløb på tværs af filer. To fokuserede gennemløb slår ét ufokuseret gennemløb.

# 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 concerns

Koordinatorer opdeler adaptivt

I et multiagent-system med hub og eger opdeler koordinatoren målet, delegerer til underagenter og samler derefter resultaterne. Det er adaptiv opdeling på orkestreringslaget — koordinatoren beslutter, hvordan opgaven skal opdeles, ud fra forespørgslen.

Kritisk: underagenter arver ikke koordinatorens samtalehistorik. Hver prompt til en underagent skal indeholde hele konteksten eksplicit. Flere Task-kald i ét svar kører parallelt — det er nyttigt, når delproblemerne er uafhængige.

# 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."""

Sessioner: Genoptag, forgren eller start forfra

Adaptivt arbejde strækker sig ofte over flere sessioner. Claude Code giver dig --resume <name> til at fortsætte en navngiven session og fork_session til at forgrene fra et fælles punkt og udforske alternativer parallelt.

Men pas på: genoptagne værktøjsresultater kan være forældede, hvis kodebasen er blevet ændret siden. Nogle gange er en ny session med et struktureret resumé bedre end at genoptage — du får den aktuelle tilstand plus den sammenfattede kontekst uden at slæbe forældede værktøjsresultater med.

# 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: ..."

En tjekliste til beslutninger

Spørg dig selv, før du bygger:

Kender jeg trinnene på forhånd i en fast rækkefølge? -> fast pipeline / promptkædning.
Afhænger det næste trin af det, de tidligere trin afslører? -> adaptiv agentbaseret løkke.
Er det meste fast, men ét trin er usikkert? -> hybrid: kæd det ydre flow, og indlejr en adaptiv løkke.
Gennemgår du mange filer? -> opdel i gennemløb pr. fil efterfulgt af gennemløb på tværs af filer.

Og altid: afslut adaptive løkker ved stop_reason, og brug kun grænser for antal iterationer som et sikkerhedsnet.

Hurtigt tjek

En scenariebaseret beslutning om valg af opdelingsstrategi.

Besvar den i den interaktive lektion

Opsummering

Vigtigste pointer:

Fast pipeline (promptkædning) til kendte trin i en bestemt rækkefølge — forudsigelig, nem at fejlfinde og billig.
Adaptiv opdeling til undersøgelser uden fast slutpunkt, hvor det næste trin afhænger af det, du opdager.
Hybrid er almindeligt: et fast ydre flow med et indlejret adaptivt trin.
Afslut altid adaptive løkker ved stop_reason (end_turn); grænser for antal iterationer er et sikkerhedsnet, aldrig den primære afslutning. Du må aldrig analysere tekst for "done."
Ved gennemgang af flere filer skal du opdele arbejdet i et gennemløb pr. fil efterfulgt af et separat gennemløb på tværs af filer.
Underagenter arver ikke historikken — giv dem konteksten eksplicit. Genoptag sessioner med omtanke; en ny session med et struktureret resumé kan være bedre end forældede genoptagne værktøjsresultater.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 26
Lektioner: 104

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Faste pipelines vs. adaptiv nedbrydning” gratis?

Ja — alle 3 lektioner i læringssporet Claude Architect, inklusive “Faste pipelines vs. adaptiv nedbrydning”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Claude Architect-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Faste pipelines vs. adaptiv nedbrydning”?

Prompt chaining til kendte trin; adaptiv nedbrydning til åbne opgaver Du øver dig i Claude Architect med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Claude Architect?

Der kræves ingen tidligere erfaring. Claude Architect på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Faste pipelines vs. adaptiv nedbrydning”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Claude Architect-lektion?

Ja. Alle Claude Architect-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Claude Architect