Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Ræsonnement til kode og fejlfinding

Lektion 10 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Fejlfinding: Et ræsonnementsproblem
  2. Klassisk fejlfinding
  3. Analyse af kompleks kode
  4. Fejlfinding af specifikke fejl
  5. Arkitektur og refaktorering
  6. Mønster: Assistent til kodegennemgang
  7. Small 4 eller Large 4 til kode?
  8. Vigtige pointer

Lektion opdateret 2. november 2026. De oprindelige eksempler brugte Magistral, som blev udfaset 31. juli 2026. De benytter nu Mistral Small 4 (mistral-small-2603) eller Mistral Large 4 (mistral-large-4-0) med reasoning_effort="high" og parser svaret ved hjælp af funktionen separer fra lektion 3. Kilde: Reasoning (Mistral-dokumentation).

Fejlfinding: Et ræsonnementsproblem

Hvorfor gavner fejlfinding mere af ræsonnement end kodegenerering? Fordi kodegenerering primært er en øvelse i genkaldelse – modellen har set millioner af sorteringsfunktioner – hvorimod fejlfinding er en øvelse i konfrontation. Du skal holde to ting i tankerne samtidig: hvad koden bør gøre, og hvad den faktisk gør, for derefter at lokalisere kløften. Dette er præcis den type opgave, hvor det at tænke, før man svarer, ændrer resultatet.

At finde en fejl er fundamentalt set en ræsonnementsøvelse. Du skal forstå hensigten, spore eksekveringen, identificere afvigelsen mellem forventet og faktisk adfærd og formulere en løsning. Det er præcis her, ræsonnementet gør forskellen.

Klassisk fejlfinding

Bemærk formen på forespørgslen i dette eksempel. Vi siger ikke „ret denne kode”. I stedet beskriver vi symptomet – hvad der skulle ske kontra hvad der sker. Dette er samme disciplin, som du bruger med en menneskelig kollega: En diagnose, der starter fra symptomet, finder årsagen, mens et bart „ret dette” uden kontekst ofte producerer en omskrivning, der maskerer fejlen i stedet for at løse den.

from mistralai.client import Mistral

client = Mistral(api_key="YOUR_API_KEY")

buggy_code = """
def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] <= list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    return result

# Test: merge_sorted_lists([1, 3, 5], [2, 4, 6])
# Expected result: [1, 2, 3, 4, 5, 6]
# Actual result: [1, 2, 3, 4, 5]
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Python debugging expert.
Method:
1. Trace execution mentally
2. Identify where behavior diverges
3. Explain the root cause
4. Propose a fix with a test"""},
        {"role": "user", "content": f"This code has a bug. Diagnose and fix it:\n\n{buggy_code}"}
    ],
)

Modellen vil identificere, at funktionen ikke håndterer resterende elementer efter while-løkken (den mangler tilføjelsen af halerne list1[i:] og list2[j:]).

Analyse af kompleks kode

Forståelse af ældre kode (legacy code) er det andet store brugstilfælde, og det har en interessant egenskab: Ræsonnementssporingen er lige så værdifuld som selve svaret. Ved at læse, hvordan modellen rekonstruerede logikken – hvilke hypoteser den dannede, hvilke checks den udførte – får du et læsekort over koden, som en simpel endelig forklaring ikke kan give.

complex_code = """
def process(data):
    cache = {}
    def helper(n, memo=cache):
        if n in memo:
            return memo[n]
        if n < 2:
            memo[n] = n
            return n
        result = helper(n-1) + helper(n-2)
        memo[n] = result
        return result

    return [helper(x) for x in data if isinstance(x, int) and x >= 0]
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": f"""Analyze this code in depth:
1. What exactly does it do?
2. Are there any potential issues?
3. How can it be improved?

{complex_code}"""}
    ]
)

Fejlfinding af specifikke fejl

Typefejl

type_error = """
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Code:
def calculate_total(items):
    total = None
    for item in items:
        price = item.get('price')
        total = total + price
    return total
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": f"Explain this error and fix the code:\n\n{type_error}"}
    ]
)

Ydelsesproblemer

slow_code = """
def find_duplicates(lst):
    duplicates = []
    for i in range(len(lst)):
        for j in range(i + 1, len(lst)):
            if lst[i] == lst[j] and lst[i] not in duplicates:
                duplicates.append(lst[i])
    return duplicates

# This code is very slow on large lists (100,000+ elements)
"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": "Analyze the algorithmic complexity and propose an optimized version."},
        {"role": "user", "content": f"Optimize this code:\n\n{slow_code}"}
    ]
)

Arkitektur og refaktorering

Ræsonnement gælder også for arkitektoniske valg:

architecture = """My Flask application has this structure:

app.py (2000 lines):
- API routes (20 endpoints)
- Business logic
- Database access
- Data validation
- Error handling

How should I restructure this application?"""

response = client.chat.complete(
    model="mistral-small-2603",
    reasoning_effort="high",
    messages=[
        {"role": "system", "content": """Senior software architect.
Reason through SOLID principles, separation of concerns,
and long-term maintainability."""},
        {"role": "user", "content": architecture}
    ],
)

Mønster: Assistent til kodegennemgang

Kombinér ræsonnement med systematisk analyse:

def code_review(client, code, language="python"):
    """Performs an in-depth code review with reasoning."""

    review_prompt = f"""Perform a detailed code review of this {language} code.

Systematically analyze:
1. **Correctness**: Does the code do what it is supposed to do?
2. **Edge cases**: Are edge cases handled (None, empty, negative)?
3. **Performance**: What is the complexity? Is it optimal?
4. **Readability**: Is the code clear and well-named?
5. **Security**: Are there vulnerabilities (injection, XSS, etc.)?

For each issue found, indicate:
- The line number
- The severity (critical / major / minor)
- The recommended fix

Code to review:
```{language}
{code}
```"""

    response = client.chat.complete(
        model="mistral-small-2603",
        reasoning_effort="high",
        messages=[{"role": "user", "content": review_prompt}]
    )

    return separer(response.choices[0].message.content)[1]  # the answer, without the reasoning

Small 4 eller Large 4 til kode?

Ved fejlfinding og kodeanalyse afhænger valget mellem de to tilgange af problemets dybde. En simpel fejl – syntaksfejl, eksplicit undtagelse, åbenlys optimering – håndteres meget godt af Mistral Small 4 (mistral-small-2603) med reasoning_effort="high" til en beskeden token-omkostning. Reserver Mistral Large 4 (mistral-large-4-0, i Public Preview) til tilfælde, hvor årsagen ikke er synlig i selve koden: Arkitekturanalyser, subtile fejl som race conditions eller memory leaks, der kun optræder i produktion, samt komplekse kodegennemgange, hvor du skal afveje korrekthed, ydelse og sikkerhed.

# Simple bug: Small is sufficient
simple_bug = "why does 'hello'.split('')[0] raise an error?"
response = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": simple_bug}],
    reasoning_effort="high"
)

# Complex bug: Large 4, evaluate on your own cases
complex_bug = "My Django application has a memory leak in production that does not appear in dev..."
response = client.chat.complete(
    model="mistral-large-4-0",
    reasoning_effort="high",
    messages=[{"role": "user", "content": complex_bug}]
)

Vigtige pointer

  • Fejlfinding er en ideel ræsonnementsøvelse for reasoning_effort="high"
  • Guid modellen med en system-prompt, der strukturerer diagnosemetoden
  • Ræsonnement skinner ved subtile fejl, ydelsesanalyser og arkitektur
  • Small 4 i high-tilstand er tilstrækkelig til almindelige fejl; evaluer Large 4 på subtile fejl og arkitektur
  • Kombinér ræsonnement med systematisk kodegennemgang for at maksimere kvaliteten
  • Anmod altid om en verifikationstest sammen med den foreslåede løsning