Ræsonnement til kode og fejlfinding
På denne side
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) medreasoning_effort="high"og parser svaret ved hjælp af funktionenseparerfra 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