Razmišljanje za kodo in odpravljanje napak
Na tej strani
Lekcija posodobljena 2. novembra 2026. Prvotni primeri so uporabljali Magistral, ki je bil umaknjen 31. julija 2026. Zdaj uporabljajo Mistral Small 4 (
mistral-small-2603) ali Mistral Large 4 (mistral-large-4-0) z nastavitvijoreasoning_effort="high"ter odgovor razčlenijo s funkcijosepareriz lekcije 3. Vir: Reasoning (dokumentacija Mistral).
Odpravljanje napak: problem razmišljanja
Zakaj ima odpravljanje napak več koristi od razmišljanja kot generiranje kode? Ker je generiranje kode vaja v priklicu – model je videl milijone funkcij za razvrščanje –, medtem ko je odpravljanje napak vaja v soočenju. Hkrati moraš imeti v mislih dve stvari: kaj koda bi morala početi in kaj dejansko počne, nato pa najti vrzel med njima. To je točno tista vrsta naloge, kjer razmišljanje pred odgovorom spremeni izid.
Iskanje napake je v osnovi vaja razmišljanja. Razumeti moraš namen, slediti izvajanju, identificirati odstopanje med pričakovanim in dejanskim vedenjem ter oblikovati popravilo. Prav tu razmišljanje naredi razliko.
Klasično odpravljanje napak
Bodi pozoren na obliko zahteve v tem primeru. Ne rečemo „popravi to kodo”. Namesto tega opišemo simptom – kaj naj bi se zgodilo v nasprotju s tem, kar se dogaja. To je ista disciplina, kot jo uporabljaš s človeškim kolegom: diagnoza, ki izhaja iz simptoma, najde vzrok, medtem ko golo „popravi to” brez konteksta pogosto proizvede prepis, ki napako prikrije, namesto da bi jo rešil.
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}"}
],
)
Model bo prepoznal, da funkcija ne obravnava preostalih elementov po zanki while (manjka dodajanje repov list1[i:] in list2[j:]).
Analiza kompleksne kode
Razumevanje podedovane kode je drugi glavni primer uporabe in ima zanimivo lastnost: sled razmišljanja je enako dragocena kot odgovor. Z branjem, kako je model rekonstruiral logiko – katere hipoteze je oblikoval, katere preverbe je opravil – dobiš zemljevid za branje kode, ki ga preprosta končna razlaga ne more ponuditi.
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}"""}
]
)
Odpravljanje specifičnih napak
Napake tipov
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}"}
]
)
Težave z zmogljivostjo
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}"}
]
)
Arhitektura in refaktoriranje
Razmišljanje velja tudi za arhitekturne odločitve:
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}
],
)
Vzorec: asistent za pregled kode
Združi razmišljanje s sistematično analizo:
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 ali Large 4 za kodo?
Pri odpravljanju napak in analizi kode je izbira med obema pristopoma odvisna od globine problema. Preprosto napako – sintaktično napako, eksplicitno izjemo, očitno optimizacijo – zelo dobro obravnava Mistral Small 4 (mistral-small-2603) z nastavitvijo reasoning_effort="high" ob zmernih stroških žetonov. Mistral Large 4 (mistral-large-4-0, v javnem predogledu) prihrani za primere, ko vzrok ni viden v sami kodi: arhitekturne analize, subtilne napake, kot so tekmovalni pogoji ali puščanje pomnilnika, ki se pojavijo le v proizvodnem okolju, ter kompleksni pregledi kode, kjer moraš uravnotežiti pravilnost, zmogljivost in varnost.
# 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}]
)
Ključne ugotovitve
- Odpravljanje napak je idealna vaja razmišljanja za
reasoning_effort="high" - Usmerjaj model s sistemskim pozivom, ki strukturira diagnostično metodo
- Razmišljanje blesti pri subtilnih napakah, analizah zmogljivosti in arhitekturi
- Small 4 v načinu
highzadostuje za običajne napake; Large 4 ovrednoti pri subtilnih napakah in arhitekturi - Združi razmišljanje s sistematičnim pregledom kode za največjo kakovost
- Vedno zahtevaj preizkus preverjanja skupaj s predlaganim popravilom