Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Redeneren voor code en debugging

Les 10 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Debuggen: een redeneeropgave
  2. Klassiek debuggen
  3. Analyse van complexe code
  4. Specifieke fouten debuggen
  5. Architectuur en refactoring
  6. Patroon: Code Review-assistent
  7. Small 4 of Large 4 voor code?
  8. Belangrijkste punten

Les bijgewerkt op 2 november 2026. De oorspronkelijke voorbeelden gebruikten Magistral, dat op 31 juli 2026 uit dienst is genomen. Ze maken nu gebruik van Mistral Small 4 (mistral-small-2603) of Mistral Large 4 (mistral-large-4-0) met reasoning_effort="high", en parseren het antwoord met de separer-functie uit Les 3. Bron: Reasoning (Mistral-documentatie).

Debuggen: een redeneeropgave

Waarom profiteert debuggen meer van redeneren dan codegeneratie? Omdat het genereren van code een oefening in retrieval is—het model heeft miljoenen sorteeralgoritmen gezien—terwijl debuggen een oefening in confrontatie is. U moet twee dingen tegelijk voor ogen houden: wat de code zou moeten doen en wat hij daadwerkelijk doet, om vervolgens de kloof te lokaliseren. Dit is precies het soort taak waarbij nadenken voordat u antwoordt het resultaat verandert.

Het vinden van een bug is fundamenteel een redeneeroefening. U moet de intentie begrijpen, de uitvoering traceren, de afwijking tussen verwacht en feitelijk gedrag identificeren en een oplossing formuleren. Dit is precies waar redeneren het verschil maakt.

Klassiek debuggen

Let op de vorm van het verzoek in dit voorbeeld. We zeggen niet “repareer deze code”. In plaats daarvan beschrijven we het symptoom—wat er had moeten gebeuren versus wat er gebeurt. Dit is dezelfde discipline die u toepast bij een menselijke collega: een diagnose die begint bij het symptoom vindt de oorzaak, terwijl een kaal “repareer dit” zonder context vaak leidt tot een herschrijving die de bug maskeert in plaats van oplost.

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}"}
    ],
)

Het model zal identificeren dat de functie faalt bij het verwerken van resterende elementen na de while-lus (het ontbreekt aan het toevoegen van de staarten list1[i:] en list2[j:]).

Analyse van complexe code

Het begrijpen van legacy-code is het tweede belangrijke gebruiksscenario, en het heeft een interessante eigenschap: het redeneerspoor is even waardevol als het antwoord. Door te lezen hoe het model de logica heeft gereconstrueerd—welke hypothesen het vormde, welke controles het uitvoerde—krijgt u een leeskaart van de code die een simpele eindverklaring niet kan bieden.

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}"""}
    ]
)

Specifieke fouten debuggen

Type-fouten

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}"}
    ]
)

Prestatieproblemen

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}"}
    ]
)

Architectuur en refactoring

Redeneren is ook van toepassing op architecturale keuzes:

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}
    ],
)

Patroon: Code Review-assistent

Combineer redeneren met systematische 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 of Large 4 voor code?

Voor debugging en code-analyse hangt de keuze tussen de twee benaderingen af van de diepgang van het probleem. Een eenvoudige bug—syntaxfout, expliciete uitzondering, voor de hand liggende optimalisatie—wordt zeer goed afgehandeld door Mistral Small 4 (mistral-small-2603) met reasoning_effort="high" tegen een bescheiden tokencost. Reserveer Mistral Large 4 (mistral-large-4-0, in Public Preview) voor gevallen waarin de oorzaak niet direct zichtbaar is in de code zelf: architecturale analyses, subtiele bugs zoals race conditions of memory leaks die alleen in productie optreden, en complexe code reviews waarbij u een balans moet vinden tussen correctheid, prestaties en beveiliging.

# 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}]
)

Belangrijkste punten

  • Debuggen is een ideale redeneeroefening voor reasoning_effort="high"
  • Leid het model met een systeemprompt die de diagnostische methode structureert
  • Redeneren blinkt uit bij subtiele bugs, prestatieanalyses en architectuur
  • Small 4 in high-modus is voldoende voor veelvoorkomende bugs; evalueer Large 4 bij subtiele bugs en architectuur
  • Combineer redeneren met systematische code review om de kwaliteit te maximaliseren
  • Vraag altijd een verificatietest bij de voorgestelde oplossing