Ir al contenido principal
Español— Elegir un idioma
Menú

Razonamiento para código y depuración

Lección 10 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Depuración: un problema de razonamiento
  2. Depuración clásica
  3. Análisis de código complejo
  4. Depuración de errores específicos
  5. Arquitectura y refactorización
  6. Patrón: asistente de revisión de código
  7. ¿Small 4 o Large 4 para código?
  8. Puntos clave

Lección actualizada el 2 de noviembre de 2026. Los ejemplos originales utilizaban Magistral, que se retiró el 31 de julio de 2026. Ahora llaman a Mistral Small 4 (mistral-small-2603) o Mistral Large 4 (mistral-large-4-0) con reasoning_effort="high", y analizan la respuesta usando la función separer de la Lección 3. Fuente: Reasoning (documentación de Mistral).

Depuración: un problema de razonamiento

¿Por qué la depuración se beneficia más del razonamiento que la generación de código? Porque generar código es un ejercicio de recuperación: el modelo ha visto millones de funciones de ordenación. En cambio, depurar es un ejercicio de confrontación. Debes mantener dos cosas en la mente simultáneamente: lo que el código debería hacer y lo que realmente hace, para luego localizar la brecha. Este es exactamente el tipo de tarea en la que pensar antes de responder cambia el resultado.

Encontrar un error es, fundamentalmente, un ejercicio de razonamiento. Debes comprender la intención, rastrear la ejecución, identificar la divergencia entre el comportamiento esperado y el real, y formular una corrección. Aquí es precisamente donde el razonamiento marca la diferencia.

Depuración clásica

Observa la forma de la solicitud en este ejemplo. No decimos «arregla este código». En su lugar, describimos el síntoma: lo que se suponía que debía ocurrir frente a lo que está ocurriendo. Esta es la misma disciplina que usarías con un colega humano: un diagnóstico que parte del síntoma encuentra la causa, mientras que un simple «arregla esto» sin contexto suele producir una reescritura que enmascara el error en lugar de resolverlo.

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": """Experto en depuración de Python.
Método:
1. Rastrear la ejecución mentalmente
2. Identificar dónde diverge el comportamiento
3. Explicar la causa raíz
4. Proponer una corrección con una prueba"""},
        {"role": "user", "content": f"Este código tiene un error. Diagnostícalo y corrígelo:\n\n{buggy_code}"}
    ],
)

El modelo identificará que la función no gestiona los elementos restantes tras el bucle while (le falta añadir las colas list1[i:] y list2[j:]).

Análisis de código complejo

Comprender código heredado es el segundo caso de uso principal y tiene una propiedad interesante: el rastro de razonamiento es tan valioso como la respuesta. Al leer cómo el modelo reconstruyó la lógica —qué hipótesis formuló, qué comprobaciones realizó—, obtienes un mapa de lectura del código que una explicación final simple no puede ofrecer.

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"""Analiza este código en profundidad:
1. ¿Qué hace exactamente?
2. ¿Hay algún problema potencial?
3. ¿Cómo se puede mejorar?

{complex_code}"""}
    ]
)

Depuración de errores específicos

Errores de tipo

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"Explica este error y corrige el código:\n\n{type_error}"}
    ]
)

Problemas de rendimiento

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": "Analiza la complejidad algorítmica y propone una versión optimizada."},
        {"role": "user", "content": f"Optimiza este código:\n\n{slow_code}"}
    ]
)

Arquitectura y refactorización

El razonamiento también se aplica a las decisiones arquitectónicas:

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": """Arquitecto de software senior.
Razona basándote en los principios SOLID, la separación de responsabilidades
y la mantenibilidad a largo plazo."""},
        {"role": "user", "content": architecture}
    ],
)

Patrón: asistente de revisión de código

Combina el razonamiento con un análisis sistemático:

def code_review(client, code, language="python"):
    """Realiza una revisión de código en profundidad con razonamiento."""

    review_prompt = f"""Realiza una revisión detallada de este código en {language}.

Analiza sistemáticamente:
1. **Corrección**: ¿El código hace lo que se supone que debe hacer?
2. **Casos límite**: ¿Se gestionan los casos límite (None, vacío, negativos)?
3. **Rendimiento**: ¿Cuál es la complejidad? ¿Es óptima?
4. **Legibilidad**: ¿El código es claro y tiene nombres adecuados?
5. **Seguridad**: ¿Hay vulnerabilidades (inyección, XSS, etc.)?

Para cada problema encontrado, indica:
- El número de línea
- La gravedad (crítica / mayor / menor)
- La corrección recomendada

Código a revisar:
```{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]  # la respuesta, sin el razonamiento

¿Small 4 o Large 4 para código?

Para la depuración y el análisis de código, la elección entre los dos enfoques depende de la profundidad del problema. Un error simple —error de sintaxis, excepción explícita, optimización obvia— lo gestiona muy bien Mistral Small 4 (mistral-small-2603) con reasoning_effort="high" a un coste de tokens modesto. Reserva Mistral Large 4 (mistral-large-4-0, en vista previa pública) para casos en los que la causa no es visible en el propio código: análisis arquitectónicos, errores sutiles como condiciones de carrera o fugas de memoria que solo aparecen en producción, y revisiones de código complejas donde debes equilibrar corrección, rendimiento y seguridad.

# Error simple: Small es suficiente
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"
)

# Error complejo: Large 4, evalúa con tus propios casos
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}]
)

Puntos clave

  • La depuración es un ejercicio de razonamiento ideal para reasoning_effort="high"
  • Guía al modelo con un prompt de sistema que estructure el método de diagnóstico
  • El razonamiento destaca en errores sutiles, análisis de rendimiento y arquitectura
  • Small 4 en modo high es suficiente para errores comunes; evalúa Large 4 en errores sutiles y arquitectura
  • Combina el razonamiento con una revisión sistemática de código para maximizar la calidad
  • Solicita siempre una prueba de verificación junto con la corrección propuesta