AI-promptteknik · Lektion

Grundorsaksanalys för prompts

Isolera om felet ligger i kontexten, instruktionen, formatet eller modellens förmåga.

Lektion 2 av 413 steg

Grundorsaksanalys för prompts är en gratis lektion i AI-promptteknik 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 AI-promptteknik, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-promptteknik innehåller totalt 4 lektioner.

Varför rotorsaksanalys är viktig

När en prompt misslyckas finns det flera möjliga orsaker. Att slumpmässigt ändra formuleringar slösar tid och kan åtgärda symtomet utan att åtgärda grundorsaken — vilket leder till samma fel vid något annorlunda indata.

Rotorsaksanalys (RCA) är en systematisk process för att isolera den specifika orsaken till att en prompt misslyckas, så att åtgärden riktas mot det faktiska problemet.

De fyra kategorierna av grundorsaker

Varje promptfel kan spåras tillbaka till en av fyra grundorsaker:

Kontextproblem: modellen saknar information som behövs för att svara korrekt
Tvetydighet i instruktionen: instruktionen kan tolkas på flera giltiga sätt och modellen väljer fel tolkning
Formatkonflikt: två delar av prompten innehåller motstridiga formatinstruktioner
Modellens kapacitetsbegränsning: uppgiften kräver resonemang eller kunskap som modellen inte på ett tillförlitligt sätt klarar av

Grundorsak 1: Kontextproblem

Ett kontextproblem uppstår när modellen svarar fel eftersom prompten inte innehåller den information som behövs. Modellen fyller luckan med träningsdata, som kan vara inaktuell, felaktig eller hallucinerad.

Testa genom att lägga till den saknade informationen direkt i prompten och kontrollera om svaret förbättras. Om det gör det är lösningen att lägga till kontext (t.ex. via RAG-baserad informationshämtning).

# Failing prompt — no context
prompt_v1 = 'What is the current price of our Pro plan?'

# Context problem test: inject the information
prompt_v2 = '''
Our pricing (as of today):
- Free: $0/month
- Pro: $19/month
- Enterprise: $99/month

Question: What is the current price of our Pro plan?
'''
# If v2 succeeds and v1 fails -> root cause is context problem

Grundorsak 2: Tvetydighet i instruktionen

Tvetydighet i instruktionen uppstår när prompten rimligen kan tolkas på flera sätt och modellen väljer fel tolkning.

Exempel: 'Sammanfatta kort' — betyder 'kort' en mening, ett stycke eller tre punktlistor? Modellen gissar. Testa genom att ersätta den tvetydiga formuleringen med en exakt specifikation och kontrollera om felet försvinner.

# Ambiguous
prompt_ambiguous = 'Summarize the following article briefly.'

# Precise — ambiguity removed
prompt_precise = (
    'Summarize the following article in exactly 2 sentences. '
    'Do not exceed 50 words. Output only the summary, nothing else.'
)

# Test: if precise version succeeds, root cause was ambiguity
# Fix: replace vague qualifiers with exact specifications

Grundorsak 3: Formatkonflikt

En formatkonflikt uppstår när två delar av prompten innehåller motstridiga instruktioner. Modellen måste välja en och ignorera den andra — vanligtvis den nyare eller mer framträdande instruktionen.

Exempel: systemprompten säger 'svara i oformaterad text', medan användarmeddelandet säger 'använd markdown'. Modellen kan följa vilken som helst av dem, på ett inkonsekvent sätt.

# Format conflict example
system_prompt = 'You are a helpful assistant. Always respond in plain text without any formatting.'

user_message = 'List the top 5 benefits of exercise. Use markdown bullet points.'

# The model faces a conflict: plain text vs markdown.
# Detection: if output format is inconsistent across runs, look for conflicting instructions.

# Fix: ensure all format instructions agree. Move format to system prompt only.
system_prompt_fixed = (
    'You are a helpful assistant. '
    'Always respond using markdown bullet points for lists.'
)

Grundorsak 4: Modellens kapacitetsgräns

Ett fel på grund av en kapacitetsgräns uppstår när uppgiften faktiskt överstiger vad modellen tillförlitligt klarar av. Detta skiljer sig från de tre andra orsakerna – ingen ändring av prompten kommer att lösa problemet helt.

Tecken: felfrekvensen är hög även med tydliga instruktioner och fullständig kontext. Åtgärder: använd en kraftfullare modell, dela upp uppgiften i enklare steg eller lägg till ett verifieringssteg.

# Capability limit test: try the same task on different models
models = ['gpt-4o-mini', 'gpt-4o', 'gpt-4o-2024-11-20']
results = {}

for model in models:
    resp = client.chat.completions.create(
        model=model,
        messages=[{'role': 'user', 'content': complex_reasoning_prompt}]
    )
    results[model] = evaluate(resp.choices[0].message.content)

# If accuracy improves with more capable models -> capability limit
for model, score in results.items():
    print(f'{model}: {score:.0%} accuracy')

Isoleringsmetoden

För att identifiera vilken grundorsak som är aktiv använder du systematisk isolering:

Kör prompten som misslyckas och klassificera feltypen (felaktigt svar, formatfel osv.)
Lägg till information → om det fungerar: kontextproblem
Förtydliga instruktionerna → om det fungerar: tvetydighet
Granska om det finns motsägelser → om det fungerar: formatkonflikt
Uppgradera modellen → om det fungerar: kapacitetsgräns

Det ska räcka med en enda åtgärd. Om flera åtgärder krävs fanns det flera grundorsaker.

def rca_test(base_prompt, test_input, expected_output):
    results = {}

    # Test 1: base (failing) prompt
    results['base'] = run_and_evaluate(base_prompt, test_input, expected_output)

    # Test 2: add context
    results['with_context'] = run_and_evaluate(
        base_prompt + '\nContext: ' + get_context(test_input),
        test_input, expected_output
    )

    # Test 3: clarify instructions
    results['clarified'] = run_and_evaluate(
        clarify(base_prompt), test_input, expected_output
    )

    for name, passed in results.items():
        print(f'{name}: {"PASS" if passed else "FAIL"}')

Uteslutning kontra bekräftelse

RCA följer två arbetssätt:

Uteslutning: uteslut orsaker som INTE är ansvariga (testa varje hypotes och se vilken som INTE ändrar resultatet)
Bekräftelse: identifiera den orsak som, när den åtgärdas, konsekvent löser felet för flera testindata

Bekräftelse kräver minst 3 testindata. En åtgärd som fungerar för en indata men inte för andra har inte löst grundorsaken – den kan ha löst ett symtom.

def confirm_root_cause(fix_fn, test_cases, threshold=0.9):
    '''fix_fn: a function that takes a prompt and returns a fixed prompt'''
    passed = 0
    for case in test_cases:
        fixed_prompt = fix_fn(case['prompt'])
        result = run_and_evaluate(fixed_prompt, case['input'], case['expected'])
        if result:
            passed += 1

    pass_rate = passed / len(test_cases)
    print(f'Fix pass rate: {pass_rate:.0%}')
    if pass_rate >= threshold:
        print('Root cause CONFIRMED — fix is reliable.')
    else:
        print('Root cause NOT confirmed — failure has multiple causes.')

Dokumentera grundorsaken

Dokumentera grundorsaken i loggen över promptändringar när den har identifierats. Inkludera:

Observerad feltyp
Grundorsakskategori
Testad hypotes
Bevis (vilket test som klarade sig efter åtgärden)
Den specifika ändringen som gjordes i prompten

Detta hindrar framtida utvecklare från att utreda samma fel igen och gör det möjligt att upptäcka mönster mellan olika promptar.

rca_record = {
    'prompt_id': 'summarize_v3',
    'failure_type': 'wrong_format',
    'root_cause': 'format_conflict',
    'hypothesis': 'System prompt said plain text, user message asked for markdown',
    'evidence': 'Removing markdown instruction from user message resolved failure on 8/8 test cases',
    'fix_applied': 'Moved all format instructions to system prompt; removed format instructions from user template',
    'fix_date': '2024-11-15'
}

Vanligt misstag: att åtgärda fel orsak

Det vanligaste RCA-misstaget är att åtgärda symtomet i stället för orsaken. Exempel:

Symtom: modellen returnerar JSON med en extra inledande text
Felaktig åtgärd: lägg till efterbehandling som tar bort texten från utdata
Den faktiska grundorsaken: ingen formatinstruktion i prompten + modellen använder samtalsstil som standard
Korrekt åtgärd: lägg till den uttryckliga instruktionen 'Returnera endast giltig JSON. Ingen annan text.'

Speciallösningar för efterbehandling ackumulerar teknisk skuld. Grundorsaksåtgärder håller över tid.

RCA för intermittenta fel

Vissa fel är intermittenta – prompten fungerar 80 % av gångerna men misslyckas 20 %. De är svårare att diagnostisera eftersom en enstaka körning av prompten ger ett korrekt resultat.

Metod: kör prompten 10–20 gånger med samma indata. Om felfrekvensen inte är noll har prompten en probabilistisk grundorsak – vanligtvis tvetydiga instruktioner eller ett högt värde för temperature. Åtgärd: gör instruktionen mer specifik eller sänk värdet för temperature.

def measure_failure_rate(prompt, test_input, expected, runs=20):
    failures = 0
    for _ in range(runs):
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[{'role': 'user', 'content': prompt + '\n' + test_input}],
            temperature=0.7
        )
        if not evaluate(resp.choices[0].message.content, expected):
            failures += 1
    print(f'Failure rate: {failures}/{runs} = {failures/runs:.0%}')

Kunskapskontroll

En prompt begär ett JSON-svar men returnerar ibland JSON föregånget av en samtalsinledning som 'Visst! Här är JSON:'. Efter att 'Returnera endast giltig JSON. Ingen annan text.' har lagts till upphör felet. Vad var grundorsaken?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Grundorsaksanalys

De fyra grundorsakskategorierna för promptfel:

Kontextproblem: modellen saknar nödvändig information – åtgärd: lägg till kontext via RAG eller direkt inmatning
Tvetydig instruktion: vag instruktion med flera möjliga tolkningar – åtgärd: öka precisionen
Formatkonflikt: motsägelsefulla formateringsinstruktioner – åtgärd: samla dem i systemprompten
Modellens kapacitetsgräns: uppgiften överstiger modellens förmåga – åtgärd: uppgradera modellen eller dela upp uppgiften

Använd systematisk isolering för att testa varje hypotes. Bekräfta åtgärden med flera testfall. Dokumentera resultaten. Nästa lektion: systematisk felsökning med binärsökning.

Gratis att börja

Lär dig AI-promptteknik 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: 53
Lektioner: 199

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grundorsaksanalys för prompts” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen AI-promptteknik, inklusive ”Grundorsaksanalys för prompts”, 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 AI-promptteknik innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grundorsaksanalys för prompts”?

Isolera om felet ligger i kontexten, instruktionen, formatet eller modellens förmåga. Ni övar på AI-promptteknik 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 AI-promptteknik?

Du behöver inga förkunskaper. Utbildningen i AI-promptteknik 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 ”Grundorsaksanalys för prompts”?

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 AI-promptteknik-lektionen?

Ja. Varje AI-promptteknik-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

Diagnostisera oväntade resultat
Grundorsaksanalys för prompts
Systematisk felsökningsmetod
Strategier för loggning och dokumentation

← Tillbaka till AI-promptteknik