Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Põhjendamine koodi ja silumise jaoks

Õppetund 10 / 12 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Silumine: põhjendamist nõudev ülesanne
  2. Klassikaline silumine
  3. Kompleksne koodianalüüs
  4. Spetsiifiliste vigade silumine
  5. Arhitektuur ja refaktoreerimine
  6. Muster: koodi ülevaataja assistent
  7. Small 4 või Large 4 koodi jaoks?
  8. Peamised punktid

Tund uuendatud 2. novembril 2026. Algsed näited kasutasid Magistrali, mis suleti 31. juulil 2026. Nüüd kasutatakse Mistral Small 4 (mistral-small-2603) või Mistral Large 4 (mistral-large-4-0) parameetriga reasoning_effort="high" ning vastust parsitakse 3. tunnist pärit funktsiooniga separer. Allikas: Reasoning (Mistral documentation).

Silumine: põhjendamist nõudev ülesanne

Miks sobib silumiseks paremini põhjendamine kui koodi genereerimine? Sest koodi loomine on sisuliselt taastamise harjutus – mudel on näinud miljoneid sorteerimisfunktsioone –, samas kui silumine on vastandamise harjutus. Pead samaaegselt meeles pidama kaht asja: mida kood peaks tegema ja mida see tegelikult teeb, ning leidma nende vahelise lõhe. Just selliste ülesannete puhul muudab enne vastamist mõtlemine tulemust.

Vea leidmine on oma olemuselt põhjendamisülesanne. Pead mõistma kavatsust, jälgima täitmist, tuvastama lahknevuse oodatud ja tegeliku käitumise vahel ning formuleerima paranduse. Just siin teeb põhjendamine otsustava erinevuse.

Klassikaline silumine

Pane tähele päringu vormi selles näites. Me ei ütle „paranda see kood“. Selle asemel kirjeldame sümptomit – mis pidi juhtuma versus mis tegelikult juhtub. See on sama distsipliin, mida kasutad inimkolleegiga töötades: sümptomist algav diagnoos leiab põhjuse, samas kui paljas „paranda see“ ilma kontekstita toodab sageli ümberkirjutuse, mis varjab vea, selle asemel et seda lahendada.

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

Mudel tuvastab, et funktsioon ei suuda pärast while-tsüklit alles jäänud elemente käsitleda (puudub sabade list1[i:] ja list2[j:] lisamine).

Kompleksne koodianalüüs

Pärandkoodi mõistmine on teine peamine kasutusjuhtum ja sellel on huvitav omadus: põhjendamisjälg on sama väärtuslik kui vastus ise. Lugedes, kuidas mudel loogika uuesti üles ehitas – milliseid hüpoteese ta lõi, milliseid kontrolle tegi –, saad koodist lugemiskaardi, mida lihtne lõppseletus pakkuda ei saa.

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

Spetsiifiliste vigade silumine

Tüübivead

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

Jõudlusprobleemid

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

Arhitektuur ja refaktoreerimine

Põhjendamine kehtib ka arhitektuurivalikute kohta:

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

Muster: koodi ülevaataja assistent

Kombineeri põhjendamine süstemaatilise analüüsiga:

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 või Large 4 koodi jaoks?

Silumise ja koodianalüüsi puhul sõltub kahe lähenemisviisi vaheline valik probleemi sügavusest. Lihtsa vea – süntaksiviga, selge erind, ilmne optimeerimine – lahendab väga hästi Mistral Small 4 (mistral-small-2603) koos reasoning_effort="high" mõõduka tokenite kuluga. Jäta Mistral Large 4 (mistral-large-4-0, avalikus eelvaates) juhtudeks, kus põhjus ei ole koodis endas nähtav: arhitektuuri analüüsid, peened vead nagu võistlusolukorrad või mälulekked, mis ilmnevad ainult tootmises, ning komplekssed koodi ülevaated, kus pead leidma tasakaalu õigsuse, jõudluse ja turvalisuse vahel.

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

Peamised punktid

  • Silumine on ideaalne põhjendamisülesanne parameetri reasoning_effort="high" jaoks
  • Juhenda mudelit süsteemse vihjega, mis struktureerib diagnostikameetodit
  • Põhjendamine hiilgab peente vigade, jõudlusanalüüside ja arhitektuuri puhul
  • Small 4 režiimis high piisab levinud vigade jaoks; hinda Large 4 peente vigade ja arhitektuuri puhul
  • Kombineeri põhjendamine süstemaatilise koodi ülevaatusega, et maksimeerida kvaliteeti
  • Nõua pakutud parandusega alati kontrolltesti