Claude Architect · Lektion

Läsa en scenarioprompt

Identifiera området, begränsningen och kostnaden för ett fel.

Lektion 2 av 413 steg

Läsa en scenarioprompt är en gratis lektion i Claude Architect på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Claude Architect, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Claude Architect innehåller totalt 4 lektioner.

Varför läsningen kommer först

Provet Claude Certified Architect är scenariobaserat: varje fråga består av en kort situation följd av fyra alternativ, där exakt ett är rätt. Ni får se 4 av 8 scenarier, poängsätts på skalan 100–1000 och blir godkänd vid 720.

De flesta felaktiga svar beror inte på kunskapsluckor – utan på läsningsluckor. Frågan anger alltid vilket område den gäller, vilket krav som måste uppfyllas och vad det kostar när systemet fallerar. Om ni missar någon av dessa tre saker kommer ett plausibelt distraktoralternativ att fånga er.

Den här lektionen tränar en enda färdighet: att dela upp ett scenario i område, krav och konsekvens av fel innan ni ens tittar på alternativen.

De tre signalerna

Träna blicken på att hitta tre signaler i varje scenario:

Område – vilket av provets fem områden som testas. Det visar vilken mental modell som ska användas.
Krav – det hårda krav som svaret MÅSTE uppfylla (t.ex. ”måste vara deterministiskt”, ”körs i CI”, ”kontexten återställs mellan underagenter”).
Konsekvens av fel – vad som går sönder om kravet inte uppfylls (ekonomiskt, juridiskt, säkerhetsmässigt eller bara en långsam rapport). En allvarlig konsekvens förändrar vilket svar som är rätt.

Läs frågan tre gånger om det behövs – en gång per signal. Alternativen är utformade så att de felaktiga uppfyller två signaler men bryter mot en.

Signal 1 – identifiera området

Provet viktar fem områden. Om ni känner till fördelningen vet ni vad som förekommer oftast och vilken modell ni ska använda:

D1 Agent Architecture & Orchestration – 27 % (det största området)
D3 Claude Code Config & Workflows – 20 %
D4 Prompt Engineering & Structured Output – 20 %
D2 Tool Design & MCP – 18 %
D5 Context Management & Reliability – 15 %

Nyckelord ger snabb vägledning: ”coordinator/subagent” – D1; ”.mcp.json / tool description” – D2; ”CLAUDE.md / plan mode / -p” – D3; ”JSON Schema / few-shot” – D4; ”summarization / lost-in-the-middle” – D5.

# Keyword -> domain map you keep in your head:
DOMAIN_HINTS = {
    "coordinator|subagent|delegate": "D1 Agent Architecture (27%)",
    ".mcp.json|tool description|isError": "D2 Tool Design & MCP (18%)",
    "CLAUDE.md|plan mode|-p|slash command": "D3 Claude Code (20%)",
    "JSON Schema|few-shot|tool_choice": "D4 Prompt Eng & Output (20%)",
    "summarization|lost-in-the-middle|provenance": "D5 Context & Reliability (15%)",
}

Identifiera området i praktiken

Läs frågestammen och identifiera området innan ni läser vidare:

”En coordinator delegerar tre oberoende uppslag till underagenter. En underagent returnerar tomt; de andra lyckas. Hur bör systemet reagera?”

Signaler: ”coordinator”, ”subagents”, ”delegates” – detta är D1 Agent Architecture & Orchestration, specifikt scenariot Multi-Agent Research. Nu aktiveras rätt mentala modell: underagenter ärver inte historik, skilj på ett access FAILURE och ett giltigt EMPTY-resultat och returnera delresultat med täckningsannoteringar i stället för att avbryta hela arbetsflödet.

Genom att identifiera området i förväg laddar ni rätt antimönster att avvisa.

from anthropic import Anthropic

client = Anthropic()
# Coordinator delegates; each subagent gets context EXPLICITLY -
# subagents do NOT inherit the coordinator's conversation history.
subagent_prompt = (
    "You are a research subagent. Context: " + shared_facts + "\n"
    "Task: look up Q3 revenue for ACME. Return partial results "
    "and a coverage note if data is missing."
)

Signal 2 – kravet

Kravet är det som svaret inte får bryta mot. Det är ofta en enda bärande formulering. Var uppmärksam på dessa signaler:

”must never” / ”guarantee” / ”always block” – kräver DETERMINISTISK kontroll (en hook), inte en prompt.
”in CI” / ”in a pipeline” – kräver icke-interaktivt -p med --output-format json.
”blocking” / ”pre-merge” / ”time-sensitive” – utesluter Batch API (inget SLA för svarstid).
”shared via VCS” jämfört med ”personal” – projektets ./CLAUDE.md jämfört med användarens ~/.claude/CLAUDE.md.

Kravet är det som skiljer två alternativ åt när de annars ser identiska ut.

Krav som tvingar fram determinism

Den vanligaste kravfällan är en regel med ekonomiska, juridiska eller säkerhetsmässiga konsekvenser. Faktabladet är tydligt: hooks är 100 % deterministiska, medan prompts är cirka 90 % probabilistiska. När ett fel blir kostsamt är vägledning i en prompt fel svar.

Om frågan säger ”refunds över 500 dollar måste kräva godkännande” är det rätta alternativet en hook för utgående anrop som blockerar åtgärden – inte ”lägg till en tydlig instruktion i systemprompten”. Samma logik gäller identitetsverifiering: ett programmässigt förvillkor (blockera process_refund tills get_customer returnerar ett verifierat ID) är bättre än vilken formulering som helst.

# Deterministic enforcement - a hook, not a prompt.
def pre_refund_hook(tool_call, state):
    if tool_call.name == "process_refund":
        if not state.get("verified_customer_id"):
            return block("Identity not verified")
        if tool_call.input["amount"] > 500:
            return block("Refund > $500 requires human approval")
    return allow()

Signal 3 – konsekvensen av fel

Konsekvensen av fel är den faktor som avgör vilken avvägning som vinner. Provet belönar att mekanismens styrka matchas mot kostnaden för att göra fel.

Allvarlig konsekvens (pengar/juridik/säkerhet): välj deterministiska garantier – hooks, förvillkor och strukturerad validering. Nöj er aldrig med ”troligen rätt”.
Lindrig konsekvens (en granskning över natten, en utkastad rapport): billigare, långsammare och modellstyrda lösningar fungerar bra – Batch API till 50 % lägre kostnad eller adaptiv uppdelning.

En korrekt mekanism kan fortfarande vara fel svar om den används där kostnaden inte motiverar den och ett enklare alternativ passar bättre – men att skydda en kostsam felkonsekvens otillräckligt är alltid fel.

Kostnaden avgör mekanismen

Koppla kostnaden till rätt verktyg. Batch API är 50 % billigare och har ett fönster på upp till 24 timmar, men inget SLA för svarstid och inget verktygsanrop i flera turer – perfekt för en efterlevnadsgranskning över natten, men uteslutet för en kontroll före merge.

Om ett scenario säger ”validera varje pull request före merge” är konsekvensen av fel en blockerad utvecklare och en trasig main-branch – det är tidskritiskt, så Batch går bort och en interaktiv -p-granskningssession är rätt val.

# Time-sensitive / blocking -> NON-interactive CI run, NOT Batch.
claude -p "Review the diff for correctness bugs only" \
  --output-format json \
  > review.json
# Batch API (50% cheaper, <=24h, no SLA) is for overnight audits,
# never for a pre-merge gate.

Kombinera alla tre signalerna

Kombinera nu signalerna i en fullständig frågestam:

”En supportagent hanterar återbetalningar. Policyn säger att återbetalningar över 500 dollar kräver mänskligt godkännande. Teamet lade till en mening i systemprompten, men några stora återbetalningar slank ändå igenom. Vad bör de göra?”

Område: D1 – Customer Support Agent.
Krav: regeln om 500 dollar måste gälla varje gång (”must”).
Konsekvens av fel: ekonomisk – pengar lämnar systemet utan godkännande.

Alla tre signaler pekar åt samma håll: ersätt den probabilistiska prompten med en deterministisk hook för utgående anrop. Läsningen gjorde jobbet; svaret är nu uppenbart.

signals = {
    "domain": "D1 - Customer Support Agent",
    "constraint": "refunds > $500 MUST get human sign-off",  # 'must'
    "failure_cost": "financial",                              # high
}
# high cost + 'must' -> deterministic enforcement
verdict = "Outgoing-call hook (block), NOT a system-prompt sentence"

Distraktorer angriper en signal

Distraktorer är utformade för att uppfylla två signaler och i det tysta bryta mot den tredje. Lär er känna igen formerna:

Rätt område, rätt avsikt, fel mekanismstyrka – ”lägg till en tydlig formulering i prompten” när en hook krävs.
Rätt mekanism, fel krav – ”använd Batch API” för en blockerande kontroll.
Plausibelt men ett känt antimönster – att tolka text efter ”done”, använda iterationsgränser som primär stoppmekanism, kräva ett schemafält som kanske saknas, granska flera filer i en enda genomgång eller låta samma session granska sig själv.

När två alternativ känns nära varandra, hitta signalen de inte är överens om – det är hela frågan.

En återanvändbar läsrutin

Använd denna rutin på varje scenario, i ordning:

1. Område – skanna efter ett nyckelord och ange D1–D5.
2. Krav – stryk under den bärande formuleringen (”must”, ”in CI”, ”blocking”, ”shared”).
3. Konsekvens av fel – ekonomi/juridik/säkerhet = allvarlig; rapport/utkast = lindrig.
4. Förutsäg svaret INNAN ni läser alternativen.
5. Eliminera alla alternativ som bryter mot kravet eller motsvarar ett vanligt antimönster.

Kom också ihåg: det finns ingen bestraffning för att gissa. När ni har eliminerat alternativ, välj det bästa återstående och gå vidare – besvara varje fråga.

# Mental checklist as pseudocode you run per question:
for scenario in exam:
    domain   = name_domain(scenario)        # D1..D5
    constraint = find_must_phrase(scenario) # the hard requirement
    cost     = failure_cost(scenario)       # high | low
    guess    = predict_answer(domain, constraint, cost)
    answer   = eliminate_antipatterns(options, constraint) or guess
    # never leave it blank - no penalty for guessing

Snabbkontroll

Tillämpa rutinen med de tre signalerna på scenariot i frågan.

Besvara frågan i den interaktiva lektionen

Sammanfattning – läs innan ni svarar

Att läsa ett scenario noggrant är den mest värdefulla färdigheten på provet. Lås fast rutinen:

Område – skanna efter nyckelord för D1–D5; rätt mental modell aktiveras samtidigt.
Krav – hitta den bärande formuleringen; ”must/guarantee” tvingar fram determinism, ”in CI” tvingar fram -p, ”blocking” utesluter Batch och ”shared” pekar på projektets CLAUDE.md.
Konsekvens av fel – allvarlig (pengar/juridik/säkerhet) kräver hooks och förvillkor; lindrig tillåter billigare och modellstyrda lösningar.

Förutsäg svaret innan ni läser alternativen, eliminera allt som bryter mot kravet eller motsvarar ett vanligt antimönster och – eftersom det inte finns någon gissningsbestraffning – välj alltid ett svar. Läs de tre signalerna först, så slutar rätt alternativ att vara en gissning.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 26
Lektioner: 104

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Läsa en scenarioprompt” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Claude Architect, inklusive ”Läsa en scenarioprompt”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Claude Architect innehåller totalt 4 lektioner.

Vad lär jag mig i ”Läsa en scenarioprompt”?

Identifiera området, begränsningen och kostnaden för ett fel. Ni övar på Claude Architect med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Claude Architect?

Du behöver inga förkunskaper. Utbildningen i Claude Architect på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Läsa en scenarioprompt”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Claude Architect-lektionen?

Ja. Varje Claude Architect-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Claude Architect