Comparativa real entre Claude, ChatGPT y Gemini resolviendo un problema en Python. Analizamos código, claridad y resultados para ver cuál IA destaca más.
Claude vs ChatGPT vs Gemini: probé un reto real de programación y uno arrasó
Seguro has visto ese meme donde alguien abre varios chatbots de inteligencia artificial en distintas pestañas, les lanza el mismo problema de programación y luego se queda con la mejor respuesta. Es una idea simple, pero bastante interesante si quieres comparar cómo piensa cada modelo.
Decidí hacer exactamente eso, pero de forma más estructurada. Elegí tres de las IA más populares del momento —Claude, ChatGPT y Gemini— y les planteé el mismo reto de código para ver cómo se desempeñaban en condiciones similares.
El objetivo no era solo ver quién “acierta”, sino analizar cómo resuelven el problema: claridad del código, calidad de la explicación, buenas prácticas y utilidad en un contexto real. El resultado fue más revelador de lo que esperaba.
Qué es Claude AI y cómo se usa: guía práctica para principiantes
Ni demasiado fácil ni demasiado difícil: encontrar el punto medio
Para esta prueba, lo primero fue elegir un problema adecuado. No quería algo demasiado simple como “buscar duplicados en una lista”, porque la mayoría de las IA lo resolverían de forma casi idéntica.
Tampoco quería algo tipo LeetCode, ya que suele ser demasiado técnico y poco accesible para muchos usuarios. La idea era encontrar un punto intermedio: algo útil, comprensible y con margen para distintas soluciones.
Además, había otro detalle importante: el problema no debía tener una única respuesta correcta. Eso permite ver mejor la creatividad, el enfoque y la capacidad de diseño de cada IA.
Con todo eso en mente, elegí un clásico con aplicación real: un verificador de fortaleza de contraseñas. Es algo que todos hemos visto al registrarnos en una web: introduces una contraseña y el sistema te indica si es débil, media o fuerte, junto con sugerencias para mejorarla.
Este tipo de problema me permite evaluar varios aspectos:
- Cómo estructura cada IA la solución
- Qué tan limpio y entendible es el código
- Si sigue buenas prácticas
- Qué tan útil sería para un usuario real
Diseñando el prompt
Cuánta guía necesita cada IA para dar su mejor respuesta
Con el problema definido, el siguiente paso fue plantear el prompt. Para mantener la comparación justa, decidí dar exactamente la misma instrucción inicial a las tres IA.
La primera respuesta sería clave, ya que refleja qué tan bien pueden resolver el problema sin ayuda adicional. Después, según el resultado, podría hacer preguntas de seguimiento como mejorar el código, explicar detalles o manejar casos límite.
Este fue el prompt utilizado:
«Write a Python function that checks the strength of a password and labels it as Weak, Medium, or Strong.
Explain your logic clearly for a beginner.»
Es un prompt corto y directo a propósito. La idea es ver cuánto puede aportar cada IA por sí sola sin instrucciones demasiado específicas.
ChatGPT
Código limpio, explicación correcta pero mejorable
Para esta prueba utilicé la versión gratuita web de ChatGPT, con el modelo GPT 5.2. Este fue el resultado:
import re
def check_password_strength(password):
length = len(password)
# Conditions
has_lower = re.search(r"[a-z]", password)
has_upper = re.search(r"[A-Z]", password)
has_digit = re.search(r"[0-9]", password)
has_special = re.search(r"[!@#$%^&*(),.?\":{}|<>]", password)
score = 0
# Scoring rules
if length >= 8:
score += 1
if has_lower:
score += 1
if has_upper:
score += 1
if has_digit:
score += 1
if has_special:
score += 1
# Strength levels
if score <= 2:
return "Weak"
elif score == 3 or score == 4:
return "Medium"
else:
return "Strong"ChatGPT optó por usar el módulo re de Python para trabajar con expresiones regulares, lo cual es interesante. Sin embargo, para alguien que está empezando, esperaba una solución más basada en lógica básica en lugar de regex.
Eso sí, el propio ChatGPT añadió al final que podía ofrecer una versión más simple si lo pedía, lo cual es un buen detalle.
En cuanto al código, está bien estructurado y es fácil de leer. Incluso alguien con conocimientos básicos podría entenderlo sin demasiados problemas.
Los comentarios dentro del código son bastante simples: describen qué hace cada bloque, pero no profundizan demasiado en el “por qué”. La explicación posterior sigue la misma línea: correcta, pero algo superficial.
Otro punto importante es que la solución es bastante minimalista. Cumple con lo que pedí (una función), pero no va más allá:
- No pide entrada al usuario
- No muestra mensajes claros
- No ofrece sugerencias sobre la contraseña
En otras palabras, funciona, pero está lejos de ser un programa completo listo para usar.
ChatGPT también añadió algunas líneas de prueba:
print(check_password_strength("abc")) # Weak
print(check_password_strength("abc12345")) # Medium
print(check_password_strength("Abc@12345")) # Strong
Gemini
Sistema débil, pero muy fácil de entender para principiantes
Para Gemini utilicé la versión web gratuita con el modelo Gemini 3 Fast. Este fue el resultado:
def check_password_strength(password):
# Initialize our score
score = 0
length = len(password)
# 1. Check Length
if length >= 8:
score += 1
# 2. Check for Uppercase letters
has_upper = any(char.isupper() for char in password)
if has_upper:
score += 1
# 3. Check for Numbers
has_digit = any(char.isdigit() for char in password)
if has_digit:
score += 1
# Final Labeling Logic
if length < 5:
return "Very Weak (Too short!)"
if score == 3 and length >= 10:
return "Strong"
elif score >= 2:
return "Medium"
else:
return "Weak"
# Testing the function
print(f"'12345': {check_password_strength('12345')}")
print(f"'Password123': {check_password_strength('Password123')}")
print(f"'qwerty': {check_password_strength('qwerty')}")Gemini optó por un enfoque más “pythónico”, evitando expresiones regulares y utilizando generadores, métodos integrados y la función any(). Esto hace que el código sea más accesible para quienes están empezando.
Los comentarios dentro del código son más explicativos que en ChatGPT, detallando qué ocurre en cada parte. Además, la explicación posterior también es más completa, ya que va paso a paso e incluso línea por línea en algunos casos.
Sin embargo, el código no es tan limpio a nivel estructural. En lugar de separar claramente las validaciones y el sistema de puntuación, Gemini mezcla ambas cosas en el mismo flujo. Esto hace que la lectura sea menos clara de lo que podría ser.
El problema más importante, eso sí, está en la lógica. El sistema de puntuación es incompleto:
- No valida letras minúsculas
- No comprueba caracteres especiales
Esto provoca un fallo crítico: contraseñas débiles pueden clasificarse como fuertes. En un entorno real, esto sería un error grave. En resumen, es una solución fácil de entender, pero poco fiable.
Claude
Un claro ganador, y por bastante margen
Llegamos al último participante: Claude. Para esta prueba usé la versión gratuita con el modelo Sonnet 4.6. Este fue el resultado:
import re
def check_password_strength(password):
"""
Checks the strength of a password and returns a label:
'Weak', 'Medium', or 'Strong'.
"""
score = 0
feedback = []
# --- Rule 1: Length ---
# Longer passwords are exponentially harder to crack.
if len(password) >= 12:
score += 2 # Big bonus for long passwords
elif len(password) >= 8:
score += 1 # Minimum acceptable length
else:
feedback.append("Use at least 8 characters.")
# --- Rule 2: Uppercase letters (A-Z) ---
# Mixing cases increases the number of possible combinations.
if re.search(r'[A-Z]', password):
score += 1
else:
feedback.append("Add at least one uppercase letter.")
# --- Rule 3: Lowercase letters (a-z) ---
if re.search(r'[a-z]', password):
score += 1
else:
feedback.append("Add at least one lowercase letter.")
# --- Rule 4: Digits (0-9) ---
if re.search(r'[0-9]', password):
score += 1
else:
feedback.append("Add at least one number.")
# --- Rule 5: Special characters ---
# Symbols dramatically expand the character set an attacker must guess from.
if re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
score += 2 # Big bonus — special chars are very effective
else:
feedback.append("Add at least one special character (e.g. !, @, #).")
# --- Scoring ---
# Max possible score = 7 (2+1+1+1+2)
if score >= 6:
label = "Strong 💪"
elif score >= 4:
label = "Medium ⚠️"
else:
label = "Weak ❌"
return label, score, feedback
# ── Demo ──────────────────────────────────────────────────────────────────────
test_passwords = [
"abc", # Too short, nothing good
"password123", # Common, no symbols, no uppercase
"Hello@2024", # Good mix, decent length
"X!9kP#mQ2$vL", # Long, all character types
]
for pwd in test_passwords:
label, score, tips = check_password_strength(pwd)
print(f"\nPassword : {pwd}")
print(f"Strength : {label} (score: {score}/7)")
if tips:
print("Tips :", " | ".join(tips))Desde el primer vistazo, el código se siente más profesional. Claude también utiliza expresiones regulares, pero con una implementación más estructurada y completa.
Empieza con un docstring, algo muy habitual en código real, explicando qué hace la función. Los comentarios son claros y útiles, hasta el punto de que podrías entender el código sin necesidad de leer la explicación externa. Eso sí, esta abundancia de comentarios hace que el código se vea un poco más cargado.
En cuanto al sistema de puntuación, cubre prácticamente todos los casos esperados:
- Longitud de la contraseña
- Uso de mayúsculas y minúsculas
- Números
- Caracteres especiales
Además, añade mejoras interesantes, como puntos extra para contraseñas largas o más complejas.
Pero lo que realmente marca la diferencia es el feedback al usuario. Si la contraseña no cumple ciertos criterios, Claude genera sugerencias claras sobre qué mejorar. Este detalle lo acerca mucho más a un uso real, y es algo que esperaba ver también en los otros modelos.
También incluye una pequeña sección de pruebas para facilitar la verificación del código, lo cual es otro punto a favor.
En cuanto a la explicación, es quizás su punto más débil. Está más enfocada en describir el sistema general que en detallar línea por línea el código, como sí hace Gemini. Aun así, gracias a los comentarios internos, esto no se vuelve un problema serio.
En conjunto, Claude ofrece la solución más completa, práctica y cercana a un escenario real, lo que lo convierte en el claro ganador de esta prueba.
Conclusión
No todas las IA programan al mismo nivel
Este experimento deja algo claro: aunque todas estas IA pueden resolver problemas de programación, no lo hacen de la misma manera ni con el mismo nivel de calidad.
ChatGPT destaca por su código limpio y correcto, pero se queda algo corto en profundidad. Gemini brilla en la explicación y accesibilidad, pero falla en aspectos clave de la lógica. Claude, en cambio, logra el mejor equilibrio entre estructura, funcionalidad y utilidad real.
Más allá del resultado, lo interesante es ver cómo cada modelo aborda el mismo problema con enfoques distintos. Esto no solo ayuda a elegir la herramienta adecuada, sino también a entender mejor cómo aprovechar cada una según el contexto.
