Probablemente hayas visto el meme en el que un tipo abre todos los chatbots de IA populares en diferentes pestañas del navegador, les da el mismo mensaje de codificación, verifica el resultado de cada uno y luego copia el mejor. Por un momento pensé en hacer el mismo experimento. Entonces, elegí tres de las IA más populares y les di el mismo problema para resolver. Así es como se desempeñó cada uno.
Elegir un problema adecuado y juzgar criterios.
No es demasiado fácil ni demasiado desafiante, conseguir ese punto medio
Para esta prueba, estaba pensando en qué tipo de desafío de codificación podría elegir. No quería elegir algo como «buscar duplicados en una lista» porque la mayoría de las IA lo abordarían de la misma manera. Tampoco quería probar un problema estilo LeetCode porque a muchos se les pasaría por alto.
Además, también quería probar con algo con lo que la mayoría de la gente pueda identificarse, que tenga algún tipo de funcionalidad en el mundo real y no tenga una respuesta definitiva. En particular, no tener una respuesta definitiva lo hace más interesante ya que pude observar el nivel de pensamiento y creatividad de cada IA.
Con eso, el problema que finalmente decidí fue «verificar la seguridad de la contraseña». Normalmente los verás en acción cuando te registras en un servicio. Al crear una contraseña, el sistema a menudo le muestra qué tan segura es su contraseña y qué debe hacer para fortalecerla.
Puedo usar este programa para probar qué tan bien cada IA diseña las soluciones, su estilo de codificación, si siguen las mejores prácticas, la facilidad de uso y si las soluciones son estándar de la industria. Las puntuaciones se basarán en estos criterios.
Diseñando el mensaje
Observar cuánta orientación necesita cada chatbot para alcanzar su mejor solución
Matt Klein / DALL-E 3 / Cómo hacerlo Geek
Una vez solucionado el problema del desafío, ahora es el momento de pensar en las técnicas de estimulación. Para mantener las cosas justas, le daré a ChatGPT, Gemini y Claude el mismo primer mensaje. Su primera salida será el factor decisivo más importante para anotar. Después del primer mensaje, puedo dar algunos mensajes de seguimiento, como explicar la solución, manejar casos extremos, refactorizar el código, etc., dependiendo de su resultado.
Aquí está el primer mensaje:
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.Lo mantuve bastante breve y simple. Esto es para ver cuánto puede pensar la herramienta de IA por sí sola sin que yo dé instrucciones explícitas.
ChatGPT
Código limpio, explicación promedio.
Para el desafío, utilicé la versión web gratuita normal de ChatGPT. El modelo utilizado fue GPT 5.2. Aquí está la solución que recibí:
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 utilizó el módulo re de Python para la búsqueda de caracteres, lo cual es interesante. Sin embargo, para un nivel principiante, esperaba que usara la lógica general de Python en lugar de expresiones regulares. ChatGPT preguntó al final de su respuesta si quería una versión que usara Python básico en lugar de expresiones regulares. De lo contrario, el código parece realmente limpio y comprensible, incluso para un principiante.
Los comentarios agregados al código son básicos y no explican lo que está haciendo. Sólo describo la sección. La explicación que ChatGPT proporcionó después de la sección del código estuvo bien. Fue sección por sección, explicando lo que hacía cada parte. Pero no fue de primera categoría.
Por último, la solución fue breve al proporcionar la función de Python que solicité. No es un programa completo que solicita información, brinda información sobre la contraseña (como un número faltante) o incluso imprime cualquier mensaje, lo que lo hace un poco menos fácil de usar y está lejos de ser un código de grado de producción. Lo único que proporcionó ChatGPT fueron algunas líneas de prueba:
print(check_password_strength("abc")) # Weak
print(check_password_strength("abc12345")) # Medium
print(check_password_strength("Abc@12345")) # Strong Géminis
Sistema débil, código y explicación fáciles de usar para principiantes
Para Gemini, elegí la versión web gratuita con el modelo Gemini 3 Fast. Aquí está la solución de Géminis:
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 Pythonic en lugar de expresiones regulares, utilizando expresiones generadoras, métodos integrados y el any() función. Los comentarios en el código son más descriptivos y explican lo que sucede en cada sección. La sección de explicación después del código también fue una buena actualización. Explicó claramente cada sección e incluso línea.
Sin embargo, a diferencia del código de ChatGPT, es menos limpio. Se habría visto mejor si las comprobaciones estuvieran agrupadas y las condiciones de puntuación estuvieran agrupadas. Pero Gemini unió la verificación y la puntuación relacionada, lo que hizo que el código fuera menos legible.
El mayor problema del código de Gemini es su sistema de puntuación. No hay verificación de letras minúsculas ni de caracteres especiales, lo que hace que el programa no sea apto para el uso en el mundo real. Incluso una contraseña débil se mostrará como segura en este sistema.
claudio
El claro ganador por kilómetros de diferencia
Llegando a nuestro último concursante, Claude. Para ello utilicé la versión web gratuita, seleccionando el modelo Sonnet 4.6. Aquí está 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 principio, el código parece profesional. Claude también usó expresiones regulares para los cheques. Tiene un sistema de puntuación bien pensado.
Comenzó la función con una cadena de documentación que explica lo que hace, lo cual es muy común en la codificación del mundo real. Los comentarios agregados son descriptivos, lo que hace que la parte del código se explique por sí misma. Incluso si no fuera a la sección de explicación, aún sabría qué hace el código aquí. Aunque debo decir que los comentarios hicieron que el código fuera menos limpio.
Para el sistema de puntuación, Claude cubrió todos los escenarios comunes, al igual que ChatGPT. Una diferencia distintiva es el punto extra de Claude por las contraseñas largas y la adición de caracteres especiales, porque hacen que su contraseña sea mucho más segura. También agregó una sección de demostración para probar contraseñas con diferentes niveles de seguridad para su conveniencia.
Sin embargo, lo que hace que la solución de Claude sea más elegante es la feedback parte. Para cada verificación, si su contraseña no aparece, Claude usa un feedback lista para agregar sugerencias sobre lo que necesita hacer. Honestamente, esperaba esto de los otros dos robots de IA, pero me decepcionaron.
Sin embargo, para ser justos, la sección de explicación de Claude fue un poco débil en comparación con Gemini y ChatGPT. Se centró más en explicar el sistema y cómo funciona que en explicar el código en sí. Sin embargo, los comentarios son bastante útiles, lo que los hace suficientes para cubrir el vacío en la explicación, lo que le valió a Claude nuestro ganador para este desafío.
No todas las IA tienen las mismas capacidades de codificación
Este fue un experimento divertido que destacó cómo cada robot de IA entendió el desafío de la codificación, lo procesó e implementó la solución. Todos sus enfoques tenían lados buenos y malos. Esto realmente te hace pensar en el futuro de la IA y la codificación.