Põhjendamine koodi ja silumise jaoks
Sellel lehel
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) parameetrigareasoning_effort="high"ning vastust parsitakse 3. tunnist pärit funktsioonigaseparer. 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
highpiisab 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