Criterios de gravedad con ejemplos
Acompañe cada nivel de gravedad con un ejemplo de código.
Criterios de gravedad con ejemplos es una lección gratuita de Claude Architect en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Claude Architect, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Claude Architect incluye 4 lecciones en total.
Por qué la severidad necesita criterios
Cuando pide a Claude que revise código, la instrucción más débil que puede darle es una indicación vaga: be more precise o only flag important issues. El modelo no tiene una definición compartida de "importante", por lo que su criterio varía de un archivo a otro.
El principio del examen es claro: los criterios explícitos son mejores que los adjetivos vagos. Una escala de severidad (Critical / High / Medium / Low) solo resulta útil si cada nivel tiene una regla escrita que el modelo pueda aplicar de forma coherente; y la manera más fiable de concretar una regla es anclarla con un ejemplo de código concreto.
En esta lección creará una rúbrica de severidad para un agente de revisión de CI/CD, nivel por nivel, vinculando cada uno a un ejemplo.
El modo de fallo: adjetivos sin anclajes
Este es el tipo de prompt que parece correcto, pero funciona mal. Menciona niveles de severidad, pero nunca los define, así que el modelo adivina, y sus respuestas cambian en cada ejecución.
El resultado es exactamente el antipatrón que advierte el examen: revisiones ruidosas en las que tanto la ausencia de una comprobación de null como un comentario con errores ortográficos reciben la etiqueta "High". Los revisores dejan de confiar en las etiquetas.
system = (
"You are a code reviewer. "
"Rate each issue as Critical, High, Medium, or Low. "
"Be precise and only report important problems."
)
# Problem: 'important', 'precise', and the four levels are
# never defined. The bar is whatever the model infers today.La solución: una regla y un ejemplo por nivel
La solución es estructural. Para cada nivel de severidad, proporcione al modelo dos elementos:
- Una regla: una condición comprobable ("causa pérdida de datos, una vulneración de seguridad o un fallo en producción").
- Un ejemplo de referencia: un fragmento breve que pertenezca inequívocamente a ese nivel.
Esto es prompting few-shot aplicado a una rúbrica: 2-4 ejemplos específicos por cada ambigüedad. El modelo generaliza a partir de los ejemplos de referencia; no se limita a repetirlos, por lo que unos pocos ejemplos bien elegidos calibran toda la escala.
Critical: ancle el nivel con un ejemplo de seguridad
Critical se reserva para problemas que causan pérdida de datos, una vulneración de seguridad o un fallo en producción. Ancle el nivel con algo indiscutible; en este caso, la interpolación directa de cadenas en SQL.
Observe que el ejemplo de referencia cumple una doble función: define el límite superior de la escala, para que el modelo sepa que nada menos grave debe alcanzar este nivel.
CRITICAL = """
Critical: causes data loss, a security breach, or a
production crash. Always report, even if low-confidence.
Example (SQL injection):
query = f"SELECT * FROM users WHERE id = {user_input}"
db.execute(query)
Why: user_input is interpolated unescaped -> injectable.
"""High: ancle el nivel con un error lógico
High abarca comportamientos incorrectos que no hacen que el proceso falle, pero producen resultados erróneos: un error lógico, un caso límite defectuoso o un error de uno. El ejemplo de referencia concreta el límite con Critical: no hay vulneración ni fallo, pero el resultado es incorrecto.
HIGH = """
High: produces incorrect results or a test failure, but
does not breach security or crash production.
Example (off-by-one):
for i in range(len(items) - 1):
process(items[i]) # last item never processed
Why: range stops one element early; silent wrong output.
"""Medium y Low: ancle el extremo discreto
El extremo inferior de la escala es donde los prompts vagos generan más falsos positivos, así que debe anclarse con el mismo cuidado.
- Medium: riesgo de mantenibilidad o fiabilidad que todavía no es un error (por ejemplo, la falta de un tiempo de espera o una ruta de error no gestionada, pero poco frecuente).
- Low: solo estilo y nombres; sin impacto en el comportamiento.
Definir Low explícitamente es lo que le permitirá decir más adelante "no informe de problemas Low en las comprobaciones previas a la combinación" sin que el modelo lo cuestione.
MEDIUM = """
Medium: reliability or maintainability risk, not yet a bug.
Example:
requests.get(url) # no timeout -> can hang forever
"""
LOW = """
Low: style or naming only, no behavioral impact.
Example:
def calc(x): return x*2 # name 'calc' is unclear
"""Compile la rúbrica en el system prompt
Los niveles anclados se convierten en un bloque del system prompt. Mantenga este bloque estable y al principio: es el mismo para todos los archivos que revise, lo que lo convierte en un prefijo ideal para la caché de prompts. El diff de cada archivo debe ir en el turno del usuario, después de la rúbrica almacenada en caché.
import anthropic
client = anthropic.Anthropic()
system = [{
"type": "text",
"text": "You are a code reviewer.\n"
+ CRITICAL + HIGH + MEDIUM + LOW
+ "\nAssign exactly one level per finding using the\n"
"rules and examples above. When unsure between two\n"
"levels, pick the lower one.",
"cache_control": {"type": "ephemeral"},
}]Fuerce la estructura: la severidad como enum
Una rúbrica escrita indica al modelo cómo decidir; la salida estructurada garantiza la forma de la respuesta. Vincule la severidad a un enum de JSON Schema para que el campo nunca pueda ser un adjetivo de texto libre como "prettyBad".
Recuerde esta regla del examen: marque un campo como required solo si está presente siempre. severity y line siempre existen en un hallazgo real, por lo que son obligatorios; un suggested_fix opcional no lo es.
finding_schema = {
"type": "object",
"properties": {
"line": {"type": "integer"},
"severity": {
"type": "string",
"enum": ["critical", "high", "medium", "low"],
},
"rule": {"type": "string"},
"suggested_fix": {"type": "string"},
},
"required": ["line", "severity", "rule"],
"additionalProperties": False,
}Conecte la rúbrica a la llamada de revisión
Ahora combine la rúbrica almacenada en caché y anclada con el esquema restringido mediante enum en una sola solicitud. El diff es la única parte volátil, por lo que se coloca al final del turno del usuario.
Esta combinación —criterios explícitos para la decisión y salida estructurada para el formato— es el patrón recomendado por el examen para realizar extracciones y clasificaciones fiables.
resp = client.messages.create(
model="claude-opus-4-8",
max_tokens=4096,
thinking={"type": "adaptive"},
system=system, # cached rubric prefix
output_config={
"format": {
"type": "json_schema",
"schema": {
"type": "object",
"properties": {"findings": {
"type": "array", "items": finding_schema}},
"required": ["findings"],
"additionalProperties": False,
},
}
},
messages=[{"role": "user", "content": diff_text}],
)La severidad determina el bloqueo, no el modelo
Una vez que la severidad es un enum limpio, la decisión de bloquear una combinación la toma código determinista, no el criterio del modelo. El modelo clasifica; su pipeline aplica los umbrales.
Esto refleja el principio de hooks del examen: cuando un fallo tiene consecuencias reales (una combinación defectuosa), aplíquelo mediante código determinista, no mediante un prompt probabilístico. La rúbrica hace que las etiquetas del modelo sean lo bastante fiables como para usarlas en el bloqueo.
import json
findings = json.loads(resp.content[0].text)["findings"]
BLOCKING = {"critical", "high"}
blockers = [f for f in findings if f["severity"] in BLOCKING]
if blockers:
print(f"BLOCK MERGE: {len(blockers)} issue(s)")
raise SystemExit(1)
print("OK to merge (medium/low only)")No permita que el modelo filtre la severidad por su cuenta
Existe una trampa sutil: decirle al modelo en la fase de hallazgos que "solo informe de Critical y High" reduce la exhaustividad; descarta silenciosamente los problemas que considera de menor nivel y usted pierde cobertura que podría haber necesitado.
El patrón sólido es hacer que el modelo informe de todos los hallazgos con su severidad y filtrar después en un paso independiente (su conjunto BLOCKING o una revisión independiente). Primero la cobertura; después la clasificación. Los criterios anclados son los que hacen fiable esa clasificación posterior.
Comprobación rápida: anclar la severidad
Aplique la lección a una decisión de diseño realista.
Recapitulación: criterios que puede señalar
Conclusiones clave:
- Los adjetivos vagos varían; las reglas escritas no. Sustituya "importante" por una condición comprobable para cada nivel de severidad.
- Ancle cada nivel con un ejemplo de código. Entre 2 y 4 ejemplos few-shot específicos calibran la escala; el modelo generaliza a partir de ellos.
- Fije la etiqueta con un enum. La salida estructurada garantiza que
severitysiempre sea uno de los valores válidos; exija solo los campos que siempre están presentes. - Almacene la rúbrica en caché y varíe el diff. Mantenga los criterios estables al principio del system prompt y coloque el código de cada archivo al final.
- Clasifique en el modelo y bloquee mediante código. Informe de todos los hallazgos con su severidad y, después, filtre o bloquee de forma determinista; nunca filtre por su cuenta durante la fase de hallazgos.
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 26
- Lecciones
- 104
Preguntas frecuentes
¿La lección «Criterios de gravedad con ejemplos» es gratis?
Sí — el texto completo de «Criterios de gravedad con ejemplos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Claude Architect, actualiza a CoddyKit PRO. El curso de Claude Architect incluye 4 lecciones en total.
¿Qué aprenderé en «Criterios de gravedad con ejemplos»?
Acompañe cada nivel de gravedad con un ejemplo de código. Practicas Claude Architect con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Claude Architect?
No se requiere experiencia previa. Claude Architect en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Criterios de gravedad con ejemplos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Claude Architect?
Sí. Cada lección de Claude Architect incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Criterios explícitos frente a instrucciones vagas
- Ejemplos categóricos
- Criterios de gravedad con ejemplos
- Reducción de falsos positivos