Claude Architect · Lektion

Iterativ förfining med exempel

2–4 indata-/utdataexempel och testdriven iteration.

Lektion 4 av 413 steg

Iterativ förfining med exempel är en gratis lektion i Claude Architect på CoddyKit. Detta är lektion 4 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 exempel slår adjektiv

När en prompt fungerar sämre tar arkitekter ofta till vaga lösningar som ”var mer precis” eller ”försök hårdare”. Dessa påverkar sällan resultatet nämnvärt. Det tillförlitliga verktyget är uttryckliga kriterier plus konkreta exempel.

Jämför "be more precise" med "flag a comment only when it contradicts the code". Det andra talar om exakt var beslutsgränsen går. I den här lektionen lär du dig att driva en prompt till produktionskvalitet med hjälp av 2–4 riktade indata-/utdataexempel och en stram loop för testning och iteration.

Så fungerar Few-Shot i praktiken

Few-shot-promptning lägger till en liten uppsättning genomarbetade exempel i dina instruktioner. Den centrala insikten är att modellen generaliserar från exemplen – den kopierar dem inte bara. Med tre representativa fall drar den slutsatsen vilken underliggande regel som gäller och tillämpar den på indata den inte har sett tidigare.

Few-shot fungerar bäst för fyra uppgifter:

  • Konsistens över många anrop
  • Gränsfall som är svåra att beskriva väl med enbart ord
  • Utdataformat som modellen ska efterlikna
  • Minskad hallucination genom att förankra beteendet

Sikta på 2–4 exempel per tvetydighet – tillräckligt många för att definiera mönstret, men tillräckligt få för att hålla kontexten kompakt.

Ett bra exempels anatomi

Ett effektivt few-shot-exempel består av en kombination av indata och den exakta utdata du vill få tillbaka. Utdata måste följa det verkliga schemat eller den verkliga struktur som du kommer att använda i produktion – samma fält, samma skiftläge och samma struktur.

Nedan visar varje exempel en inmatad kommentar tillsammans med den exakta bedömningen. Modellen lär sig gränsdragningen: flagga endast verkliga motsägelser, inte anmärkningar på stil.

examples = [
    {
        "input": "# returns the user's age\n def get_name(u): return u.name",
        "output": {"flag": True, "reason": "comment says age, code returns name"},
    },
    {
        "input": "# sort ascending\n items.sort()",
        "output": {"flag": False, "reason": "comment matches behavior"},
    },
]

system = (
    "Flag a comment ONLY when it contradicts the code. "
    "Style or wording issues are not contradictions.\n\n"
    "Examples:\n" + "\n".join(
        f"INPUT: {e['input']}\nOUTPUT: {e['output']}" for e in examples
    )
)

Kombinera kriterier med exempel

Exempel och uttryckliga kriterier kompletterar varandra; de ersätter inte varandra. Kriterier anger regeln, medan exempel kalibrerar den gråzon som regeln inte helt kan fånga i löptext.

Ett vanligt misstag av arkitekter är att hälla in exempel utan någon styrande instruktion. Då överanpassar modellen sig till ytligheten i exemplen. Börja alltid med ett tydligt kriterium – "flagga endast när X motsäger Y" – och låt sedan 2–4 exempel precisera var X och Y flyter ihop.

En tumregel: om du inte kan formulera kriteriet i en enda mening är uppgiften fortfarande otillräckligt specificerad, och fler exempel kommer inte att lösa det.

Skapa ett testset först

Iterativ förfining är testdriven. Innan du finjusterar prompten ska du sammanställa en liten märkt uppsättning representativa indata med korrekta utdata. Detta är din ground truth – varje ändring av prompten bedöms mot den, inte utifrån en magkänsla.

Håll testsetet åtskilt från dina few-shot-exempel. Om du finjusterar på samma fall som du lär ut med memorerar du i stället för att generalisera.

test_cases = [
    {"input": "# deletes the record\n def archive(r): r.archived = True",
     "expected": {"flag": True}},
    {"input": "# cache result for 60s\n cache.set(k, v, ttl=60)",
     "expected": {"flag": False}},
    {"input": "# returns count\n def total(rows): return sum(r.amt for r in rows)",
     "expected": {"flag": True}},
]

Iterationsloopen

Förfiningsloopen är mekanisk och repeterbar:

  • Kör prompten på varje testfall
  • Jämför resultatet med den förväntade etiketten
  • Undersök felen – vilken gräns missade modellen?
  • Lägg till eller skärp ett exempel (eller ett kriterium) som riktar in sig på felet
  • Kör om hela uppsättningen och kontrollera att inget försämrades

Ändra en sak per iteration. Om du gör flera ändringar samtidigt blir det omöjligt att veta vilken justering som hjälpte eller stjälpte.

Poängsätt testsetet

Automatisera jämförelsen så att iterationerna går snabbt. Ett litet harness kör varje fall, poängsätter det och skriver ut missarna. Med strukturerad utdata kan du jämföra fält direkt i stället för att tolka löptext.

Observera tool_choice nedan: genom att tvinga fram ett verktygsanrop säkerställer du att modellen alltid returnerar schema-giltig JSON, så att din poängsättning aldrig fastnar på fritext.

def score(client, system, cases):
    misses = []
    for c in cases:
        resp = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=256,
            system=system,
            tools=[verdict_tool],
            tool_choice={"type": "any"},  # must call a tool -> structured output
            messages=[{"role": "user", "content": c["input"]}],
        )
        out = resp.content[0].input
        if out["flag"] != c["expected"]["flag"]:
            misses.append((c["input"], out))
    return misses

Rikta in dig på fel med nya exempel

När du hittar ett misslyckat fall frågar du dig: vilken tvetydighet orsakade det? Lägg sedan till ett exempel som ligger precis på den gränsen – inte ett slumpmässigt nytt fall. Ett skarpt exempel per feltillstånd generaliserar mycket bättre än tio generiska exempel.

Anta att modellen felaktigt flaggade en kommentar som parafraserade koden. Då skulle du lägga till ett parat exempel som visar parafras = ingen motsägelse. Modellen uppdaterar sin interna gränsdragning, och hela klassen av liknande missar försvinner.

Motstå frestelsen att fortsätta stapla exempel på varandra. Efter ungefär fyra per tvetydighet sväller kontexten och risken för lost-in-the-middle ökar, vilket innebär att modellen ägnar mitten av en lång prompt för lite uppmärksamhet.

# Add ONE example aimed at the observed miss:
examples.append({
    "input": "# loop over each item\n for x in items: process(x)",
    "output": {"flag": False,
               "reason": "paraphrase of code, not a contradiction"},
})

Formatfel? Försök igen med återkoppling

Vissa fel gäller format eller struktur, inte resonemang – exempelvis ett felaktigt fält, en felaktig aritmetisk totalsumma eller en saknad hakparentes. För dessa är retry-with-feedback lösningen: skicka tillbaka den ursprungliga indatan, den felaktiga utdatan och det exakta valideringsfelet.

En viktig begränsning är att nytt försök hjälper när modellen kan producera rätt svar men råkade göra fel. Det hjälper inte när den information som krävs helt enkelt saknas i källan – inga nya försök kan hitta på data som inte finns.

def retry_with_feedback(client, system, original, bad_output, error):
    return client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        system=system,
        messages=[
            {"role": "user", "content": original},
            {"role": "assistant", "content": str(bad_output)},
            {"role": "user", "content":
             f"That output failed validation: {error}. "
             "Return corrected output that satisfies the schema."},
        ],
    )

Säkra kvaliteten med strukturerad utdata

När exemplen har format beteendet låser du strukturen med ett JSON Schema via verktygsanvändning. Det eliminerar syntaxfel och tvingar fram obligatoriska fält. En princip är viktigast: markera ett fält som obligatoriskt endast om det alltid finns.

Gör aldrig ett fält obligatoriskt om det kan saknas – modellen kommer att fabricera ett värde för att uppfylla schemat. För valfria eller öppna data använder du en enum med värdet "other" samt ett fritextfält för detaljer. Då förblir kontraktet utbyggbart utan att modellen tvingas hallucinera.

verdict_tool = {
    "name": "record_verdict",
    "description": "Record whether a comment contradicts its code.",
    "input_schema": {
        "type": "object",
        "properties": {
            "flag": {"type": "boolean"},
            "category": {"type": "string",
                         "enum": ["contradiction", "style", "other"]},
            "detail": {"type": "string"},
        },
        "required": ["flag"],  # only the always-present field
    },
}

Validera med en oberoende granskare

Innan du litar på den förfinade prompten ska du validera den med en oberoende, ny instans – inte samma session som skapade utdatan. En självgranskning i samma session är partisk: upphovet behåller sitt eget resonemang och kommer inte att ifrågasätta sig självt.

Lita inte heller enbart på ett sammanlagt resultat. En rubrik som 97 % träffsäkerhet kan dölja ett fält eller en indatatyp som fungerar mycket dåligt. Använd stratifierat urval och konfidens på fältnivå, kalibrerat mot ett märkt valideringsset, innan du automatiserar. Förfiningen är inte klar när genomsnittet ser bra ut – den är klar när varje delmängd klarar gränsen.

Snabbkontroll: åtgärda en prompt som misslyckas

En klassificeringsprompt klarar 92 % av ditt märkta testset men klassificerar konsekvent kommentarer som parafraserar koden som motsägelser. Vilken förfiningsåtgärd är mest effektiv?

Sammanfattning: förfina med exempel, bevisa med tester

Viktiga slutsatser:

  • Exempel slår adjektiv. Uttryckliga kriterier tillsammans med 2–4 riktade exempel presterar bättre än vaga instruktioner som ”var mer exakt”.
  • Modellen generaliserar från few-shot-exempel – de fungerar bäst för konsistens, gränsfall, utdataformat och minskad hallucination.
  • Arbeta testdrivet: skapa en märkt uppsättning, poängsätt den, lägg till ett gränsexempel per feltillstånd, kör om och ändra en sak i taget.
  • Retry-with-feedback åtgärdar formatfel (skicka ursprunglig indata + felaktig utdata + exakt felmeddelande) – inte data som saknas i källan.
  • Lås strukturen med ett JSON Schema; gör endast alltid närvarande fält obligatoriska; använd enum + ”other” + detaljer för utbyggbarhet.
  • Validera oberoende: granskning med en ny instans är bättre än självgranskning i samma session, och stratifierade kontroller på fältnivå är bättre än enbart sammanlagd träffsäkerhet.
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

Vanliga frågor

Är lektionen ”Iterativ förfining med exempel” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Claude Architect, inklusive ”Iterativ förfining med exempel”, 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 ”Iterativ förfining med exempel”?

2–4 indata-/utdataexempel och testdriven iteration. 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 4 av 4.

Hur lång tid tar lektionen ”Iterativ förfining med exempel”?

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

  1. Anpassade kommandon kontra Skills
  2. Frontmatter för Skills
  3. Planläge kontra direkt körning
  4. Iterativ förfining med exempel
← Tillbaka till Claude Architect