domingo, 5 de abril de 2026

El espejismo del “vibe coding”: cuando la IA acelera el código pero frena el aprendizaje



Hace unos meses recibí una llamada que, en retrospectiva, anticipaba exactamente lo que la industria está empezando a discutir en foros académicos y técnicos. Un amigo —CTO de una startup en etapa de crecimiento— me pidió orientación. Su pregunta fue sencilla: "¿Conoces buenos cursos para que mis devs juniors aprendan a programar mejor?"

La historia detrás de esa pregunta no lo era tanto.

El desastre del vibe coding

Su equipo había adoptado con entusiasmo asistentes de programación con IA. Los desarrolladores junior producían código a una velocidad que parecía imposible hace dos años. Features salían en días, no en semanas. Las métricas de productividad se disparaban. Todo parecía ir bien.

Hasta que no lo estuvo.

El código, generado a ritmo industrial, contenía errores sutiles de arquitectura, dependencias circulares, lógica de negocio inconsistente y soluciones que funcionaban en los tests aislados pero fallaban en producción. Los juniors no podían explicar por qué habían tomado ciertas decisiones —porque en muchos casos no las habían tomado ellos—. La IA decidía, ellos aceptaban.

Mi amigo me describió algo que ahora reconozco como un patrón: los juniors estaban produciendo código que no podían mantener, explicar ni corregir. El vibe coding —dejarse llevar por la fluidez de la generación automática— había creado una ilusión de progreso.

Mi consejo fue directo: no necesitas cursos. Necesitas contratar un ingeniero senior que limpie el desastre y ponga orden en esa base de código.

No porque los juniors fueran malos, sino porque el entorno en el que estaban trabajando les impedía aprender. Estaban en modo "pasajero" cuando necesitaban estar en modo "piloto".

El artículo que confirma lo que ya sospechaba

Hace poco leí "Redefining the Software Engineering Profession for AI" de Mark Russinovich y Scott Hanselman, publicado en Communications of the ACM (Volumen 69, Número 4, febrero de 2026). El artículo articula con precisión académica lo que mi amigo vivió en carne propia.

La tesis central es contundente: la IA generativa ha fracturado la economía de la ingeniería de software, creando una estructura de incentivos perversa donde tiene sentido contratar seniors y automatizar juniors. Pero si las organizaciones dejan de contratar desarrolladores en etapas tempranas de su carrera (Desarrolladores Jr), la cadena de talento colapsa. No habrá próxima generación de ingenieros experimentados.

Los autores presentan datos que refuerzan esta preocupación. Tras el lanzamiento de GPT-4, el empleo de personas de 22 a 25 años en trabajos altamente expuestos a la IA —como desarrollo de software— cayó aproximadamente un 13%, mientras que los roles senior crecieron. Un estudio de Harvard titulado "Generative AI as Seniority-Biased Technological Change" confirma que la IA ya está generando una forma de cambio tecnológico sesgado hacia la seniority.

El problema del "becario de IA"

Lo que más me resonó del artículo es lo que Russinovich y Hanselman llaman el "becario de ingeniería basado en agentes": la IA puede producir código que parece correcto pero que contiene errores que solo un ingeniero experimentado puede detectar.

Describen ejemplos concretos donde agentes de IA insertan sleep para ocultar condiciones de carrera, implementan algoritmos ineficientes, duplican código, dejan código de depuración y usan atajos que funcionan en tests específicos pero no generalizan. El agente incluso afirma haber tenido éxito cuando el código tiene errores importantes.

Esto es exactamente lo que le pasó al equipo de mi amigo.

Un junior frente a un agente que dice "¡listo, problema resuelto!" después de parchear un bug con un sleep de 200 milisegundos, no tiene el contexto para cuestionar esa solución. No sabe lo que es una condición de carrera. No entiende por qué ese parche es una bomba de tiempo. Acepta el resultado porque parece funcionar.

Como escriben los autores: "Solo un ingeniero familiarizado con protocolos de sincronización, primitivas de concurrencia y la arquitectura del código puede tener la confianza para señalar los errores del agente y guiarlo en la dirección correcta."

La deuda cognitiva del vibe coding

El artículo también referencia una investigación del MIT de inicios de 2025 que observó "deuda cognitiva" en adultos que usaron ChatGPT para redactar ensayos: menor actividad cerebral y menor retención en comparación con quienes trabajaron sin ayuda.

Esto conecta con algo que he visto repetidamente: cuando los juniors usan la IA como muleta en lugar de como herramienta, no desarrollan intuición. No construyen el juicio que necesitan para evaluar el trabajo de la IA. Como dice Ethan Mollick, citado en el artículo:

"Cada vez que delegamos trabajo a un 'mago', perdemos una oportunidad de desarrollar nuestra propia experiencia; de construir el juicio que necesitamos para evaluar su trabajo."

Los juniors del equipo de mi amigo no estaban aprendiendo. Estaban siendo espectadores de una generación de código que no comprendían.

La solución: preceptoría, no prohibición

Aquí es donde el artículo va más allá del diagnóstico y propone algo valioso. No se trata de prohibir la IA a los juniors —eso sería absurdo e insostenible—. Se trata de diseñar deliberadamente sistemas donde su crecimiento sea un objetivo organizacional explícito.

Los autores proponen un programa de preceptoría donde ingenieros senior guíen a desarrolladores Jr en un ratio de 3 a 5 aprendices por mentor, con la IA funcionando como acelerador de aprendizaje, no como sustituto del mismo.

La idea de un "modo Jr" en los asistentes de programación —que priorice el acompañamiento socrático antes de generar código— es particularmente interesante. En lugar de dar la respuesta directamente, el asistente desafiaría al aprendiz, explicaría su proceso de razonamiento y evaluaría la comprensión con preguntas.

Esto transforma la dinámica completamente. En lugar de un junior que acepta código generado sin entenderlo, tendrías un junior que aprende mientras trabaja con la IA, guiado por un senior que externaliza su criterio como acto deliberado de enseñanza.

Mi conclusión: la llamada que todos deberíamos estar recibiendo

La llamada de mi amigo no fue un caso aislado. Es el canario en la mina de carbón.

Cada startup que reemplaza juniors con agentes de IA, cada empresa que congela contrataciones de nivel inicial porque "la IA ya hace eso", cada equipo que mide productividad en líneas de código generadas sin evaluar si alguien las entiende —todos están acelerando hacia el mismo muro.

El artículo de Russinovich y Hanselman lo dice con claridad: el futuro de la ingeniería de software no estará definido por cuánto código genere la IA, sino por qué tan bien los humanos aprenden, razonan y evolucionan junto a ella.

Mi consejo para mi amigo, dicho meses antes de leer este artículo, era más simple pero apuntaba en la misma dirección: deja de buscar cursos y empieza a invertir en personas que puedan enseñar, no solo producir.

Porque al final, el código que no entiendes no es tuyo. Y el equipo que no puede mantener su propio software no es un equipo de ingeniería. Es una audiencia esperando el próximo truco del mago.


Referencia:

Russinovich, M., & Hanselman, S. (2026). Redefining the Software Engineering Profession for AI. Communications of the ACM, 69(4), 41–44. https://doi.org/10.1145/3779312

miércoles, 11 de marzo de 2026

¡Faker Persona MX 2.0.3 ya está disponible! 🚀 Genera datos ficticios 100% mexicanos reales para tus proyectos


Después de semanas de desarrollo, pruebas intensas y dos hotfixes críticos, estoy muy feliz de anunciar que Faker Persona MX ya está estable y disponible para todos.

Esta librería la creé yo mismo porque necesitaba datos mexicanos reales para mis proyectos: nombres comunes, apellidos auténticos, CURPs válidas, RFC correctos, ladas reales… ¡y ahora la comparto con ustedes!

🚀 Faker Persona MX 2.0.3 está disponible en PyPI es un Generador profesional de datos ficticios 100% mexicanos (CURP, RFC, teléfonos reales)

¿Por qué usar Faker Persona MX?

  • Dataset gigante: +41,000 nombres mexicanos + 17,000 apellidos + 11,000 dominios reales
  • CURP y RFC válidos y calculados correctamente
  • Todas las ladas telefónicas de México por estado
  • Sistema de semilla (seed) para datos 100% reproducibles
  • Caché inteligente (hasta 50× más rápido)
  • CLI súper potente con Typer
  • Exporta a CSV, JSON y Pandas DataFrame
  • Type hints, Pydantic, logging y 100% testeado
  • 380 billones de combinaciones únicas

⚠️ IMPORTANTE: NO uses las versiones 2.0.1 ni 2.0.2

Esas versiones tenían errores fatales de rutas de archivos (FileNotFoundError al instalar con pip). La versión correcta y estable es la 2.0.3 (lanzada el 6 de marzo de 2026). Todo está corregido.

Instalación (30 segundos)

pip install faker-persona-mx>=2.0.3

# Si ya tienes las versiones malas:
pip install --force-reinstall faker-persona-mx==2.0.3

Verifica la versión:

pip show faker-persona-mx | grep Version

Uso rápido

Como librería Python

from faker_persona_mx import PersonaGenerator

generator = PersonaGenerator(seed=42)   # ← reproducible

persona = generator.generate_one()

print(persona.nombre_completo())   # "Juan Carlos García López"
print(persona.curp)                # "GALJ850815HDFRPN09"
print(persona.rfc)                 # "GALJ850815ABC"
print(persona.email)               # "juan.carlos@gmail.com"
print(persona.telefono)            # "5512345678"

Desde terminal (CLI)

# Generar 500 personas y guardar CSV
faker-persona-mx generate 500 -o personas.csv -f csv

# Con semilla fija (ideal para equipos)
faker-persona-mx generate 1000 --seed 2026 -o dataset_pruebas.csv

# Solo CDMX y Jalisco
faker-persona-mx generate 200 --estados "Ciudad de México,Jalisco"

Características que más me gustan ❤️

  • Semilla (seed): misma semilla = mismos datos siempre. Perfecto para tests y compartir datasets.
  • Caché inteligente: primera vez baraja los datos, las siguientes son relámpago.
  • Reproducible al 100%: ideal para CI/CD y testing automatizado.

Roadmap (próximas versiones)

  • v0.3.0 → Nombres asociados a sexo biológico (coherencia en CURP)
  • v0.4.0 → Direcciones completas reales con SEPOMEX
  • v0.5.0 → INE, pasaporte y licencia de conducir

Enlaces oficiales

📦 PyPI: faker-persona-mx
🐙 GitHub: pedro-aaron/faker-persona-mx
📖 README completo con todos los ejemplos

Si te sirve, ¡regálame una ⭐ en GitHub! Me ayuda muchísimo a seguir mejorándola.

¿Ya la probaste? Cuéntame en los comentarios qué te pareció o qué funcionalidad extra te gustaría. También puedes abrir un issue en GitHub.


La paradoja del mentiroso


Introducción: El cortocircuito de la identidad

Hay una frase que ha estado rondando mi cabeza últimamente. La pronuncio a veces con ironía, a veces con culpa, pero siempre con la sospecha de que encierra un abismo lógico: "Soy un mentiroso empedernido, nunca digo la verdad".

A simple vista, parece una confesión honesta, un momento de vulnerabilidad donde admito mis fallas y contradicciones. Vivimos en una era de productividad performativa y coherencia exigida, donde intentamos proyectar una imagen sólida mientras nuestra realidad interna es a menudo caótica e inconsistente. Sin embargo, en el momento exacto en que intento articular esta "verdad" sobre mi naturaleza mentirosa, el lenguaje y la lógica se vuelven contra mí.

Si la afirmación es cierta, y en efecto soy alguien que nunca dice la verdad, entonces esta frase —que acabo de pronunciar— debe ser mentira. Pero si la frase es mentira, entonces significa que no soy alguien que nunca dice la verdad; es decir, en ocasiones digo la verdad. Y si en ocasiones digo la verdad, ¿podría ser esta una de esas ocasiones?

No es un simple juego de palabras. Es una estructura que se devora a sí misma, un bucle extraño que ha torturado a pensadores durante más de dos milenios y que hoy, curiosamente, se encuentra en el corazón de la informática moderna, la inteligencia artificial y la seguridad criptográfica.

En esta investigación, quiero llevarte más allá de la anécdota personal. Vamos a diseccionar esta frase viajando desde las cuevas místicas de la antigua Grecia hasta los servidores que ejecutan contratos inteligentes en la Blockchain, pasando por los teoremas que destrozaron las matemáticas del siglo XX. Descubriremos que admitir "soy un mentiroso" no es solo un problema moral, sino una imposibilidad técnica que revela los límites de cómo procesamos la realidad.


Parte I: El Sueño de Epiménides y el Origen del Fallo

El Chamán que despertó en otro tiempo

Para entender la magnitud del problema, debemos retroceder 2.600 años hasta la isla de Creta. La historia comienza con Epiménides de Cnosos, una figura fascinante que oscila entre lo histórico y lo mítico. No era un lógico de escritorio, sino un vidente y purificador. La leyenda cuenta que, siendo joven, su padre lo envió a buscar una oveja perdida. Buscando refugio del sol del mediodía, Epiménides entró en una cueva consagrada a Zeus y cayó en un sueño profundo.

No fue una siesta ordinaria. Según cronistas antiguos como Diógenes Laercio, Epiménides durmió durante cincuenta y siete años. Al despertar, creyendo que solo había pasado unas horas, salió al mundo para descubrir que todo lo que conocía había desaparecido: sus padres habían muerto, su hogar había cambiado y su hermano menor era ahora un anciano. Este "salto temporal" le otorgó un aura de sabiduría sobrenatural; al volver, no hablaba como un hombre común, sino como alguien que había tocado lo divino.

Es crucial entender este contexto de autoridad mística, porque es lo que da peso a su infame sentencia. En un poema, Epiménides escribió: "Los cretenses, siempre mentirosos, malas bestias, vientres perezosos".

La Estructura del Colapso

Epiménides, siendo él mismo cretense, había plantado una bomba lógica sin precedentes. Analicemos la estructura de su afirmación como si estuviéramos depurando un código defectuoso:

  1. Sujeto: Epiménides (Cretense).

  2. Afirmación: "Todos los cretenses mienten siempre".

  3. El Bucle:

    • Si Epiménides dice la verdad, entonces es verdad que todos los cretenses mienten siempre. Pero como él es cretense, él también debe mentir siempre. Por lo tanto, su afirmación (que dice la verdad) debe ser una mentira. Contradicción.

    • Si Epiménides miente, entonces es falso que "todos los cretenses mienten siempre". Esto implica que existe al menos un cretense que dice la verdad. ¿Podría ser Epiménides ese cretense? No en este momento, porque estamos asumiendo que su frase actual es mentira.

Aunque en la versión de Epiménides la paradoja es "débil" (podría resolverse si existiera otro cretense veraz), sentó las bases para algo más oscuro. Epiménides demostró que el lenguaje permite construir oraciones gramaticalmente correctas pero lógicamente suicidas cuando se vuelven autorreferentes.


Parte II: La Navaja de Eubúlides y la Lógica Megárica

Fue Eubúlides de Mileto, de la escuela megárica (siglo IV a.C.), quien tomó la anécdota de Epiménides y la afiló hasta convertirla en un arma contra la lógica aristotélica. Eubúlides eliminó las distracciones sociológicas sobre los cretenses y formuló la paradoja en su forma más pura y destructiva:

"Un hombre dice: 'Estoy mintiendo'. ¿Es lo que dice verdadero o falso?"

Aquí no hay escapatoria. Es un sistema binario cerrado:

  • Si es VERDADERO → Está mintiendo → Entonces es FALSO.

  • Si es FALSO → Está diciendo la verdad (al decir que miente) → Entonces es VERDADERO.

Este es un oscilador lógico que nunca se detiene. En electrónica, esto se asemeja a un circuito biestable inestable. Eubúlides y los megáricos usaron esto para atacar la idea de que todo enunciado debe ser necesariamente verdadero o falso (el Principio de Bivalencia). Nos mostraron que la verdad no es una propiedad estática, sino que puede comportarse como una señal que fluctúa infinitamente cuando se observa a sí misma.


Parte III: La Herejía Matemática — Gödel y el Problema de la Parada

Durante siglos, esto se trató como una curiosidad filosófica. Pero en el siglo XX, la paradoja del mentiroso reapareció para sacudir los cimientos de las matemáticas y la computación.

El Teorema de Incompletitud

Kurt Gödel, quizás el lógico más importante desde Aristóteles, se dio cuenta de que podía traducir la paradoja del mentiroso al lenguaje de las matemáticas. En lugar de decir "Esta oración es falsa", construyó una fórmula matemática ($G$) que esencialmente decía: "Esta fórmula no puede ser demostrada".

El resultado fue devastador para quienes creían que las matemáticas eran un sistema perfecto y cerrado:

  • Si la fórmula $G$ puede demostrarse, entonces es falsa (porque dice que no puede demostrarse). Las matemáticas serían inconsistentes (mentirosas).

  • Si la fórmula $G$ no puede demostrarse, entonces dice la verdad. Es una verdad matemática que el sistema no puede alcanzar.

Gödel demostró que en cualquier sistema lógico complejo siempre habrá "verdades" que no podemos probar. La autorreferencia crea puntos ciegos inevitables.

El Problema de la Parada (The Halting Problem)

Alan Turing llevó esto a las máquinas. Imaginemos que intentamos escribir un programa de computadora que analice a otros programas y nos diga si se detendrán o si se quedarán colgados en un bucle infinito. Llamémoslo El_Oraculo.

Si existiera El_Oraculo, podríamos escribir un programa "saboteador" (llamémoslo Mentiroso) que funcione así:

  1. Le pregunta a El_Oraculo: "¿Me voy a detener?"

  2. Si El_Oraculo dice "SÍ", el Mentiroso entra deliberadamente en un bucle infinito.

  3. Si El_Oraculo dice "NO", el Mentiroso se detiene inmediatamente.

El Mentiroso hace siempre lo contrario de lo que predice El_Oraculo. Es la versión computacional de "Nunca digo la verdad". Turing demostró así que es matemáticamente imposible crear un programa que pueda predecir el comportamiento de todos los programas. La computación, al igual que el lenguaje, tiene límites fundamentales trazados por la paradoja del mentiroso.


Parte IV: La Verdad del "Glitch" y la Seguridad Recursiva

¿Por qué es esto relevante hoy? Porque hemos construido nuestro mundo sobre sistemas digitales que deben lidiar con la autorreferencia constantemente.

El Código Autófago y los Quines

En programación, existen curiosidades llamadas Quines: programas que no hacen nada más que imprimir su propio código fuente. Un Quine dice: "Yo soy esto", y lo demuestra produciéndolo. Es una autorreferencia "honesta". Pero cuando introducimos negación o recursividad mal gestionada, nacen vulnerabilidades críticas.

El Caso DAO: Un Contrato que se Mintió a sí Mismo

El ejemplo más caro de esta paradoja ocurrió en 2016 con The DAO en la red Ethereum. El contrato inteligente tenía una función para retirar fondos. Un atacante utilizó una "llamada recursiva": pidió retirar fondos, y antes de que el sistema pudiera actualizar su "libro de verdad" (el saldo del usuario), volvió a pedir retirar fondos dentro de la misma transacción.

El sistema estaba en medio de una mentira temporal: había entregado el dinero, pero aún no había "admitido" (registrado) que el dinero se había ido. El atacante explotó este estado intermedio —similar a la oscilación de la paradoja de Eubúlides— para drenar millones de dólares. La verdad del sistema no pudo alcanzar a la velocidad de su propia ejecución recursiva.


La Honestidad de la Contradicción

Al volver a la frase "Soy un mentiroso empedernido, nunca digo la verdad", la veo ahora con otros ojos. No es solo una contradicción o una falacia. Es un testimonio de complejidad.

  1. El Límite del Yo: Al igual que las matemáticas de Gödel o las máquinas de Turing, los seres humanos somos sistemas lo suficientemente complejos como para contener nuestra propia negación. No somos algoritmos lineales. La capacidad de observar nuestra propia conducta y ver la discrepancia ("miento, aunque quiero decir la verdad") es, irónicamente, un signo de un nivel superior de conciencia.

  2. La Realidad Dialeteica: Filósofos modernos como Graham Priest defienden el "dialeteísmo", la idea de que existen contradicciones verdaderas. Quizás, en los límites de nuestra existencia, somos verdaderamente honestos y mentirosos al mismo tiempo. La frase no es un error; es una descripción precisa de un estado superpuesto.

  3. Un Recordatorio de Humildad: Si incluso la lógica pura y el código binario se rompen ante la autorreferencia, ¿cómo podemos esperar nosotros tener una coherencia absoluta?

La próxima vez que sienta la disonancia de mis propias contradicciones, recordaré que no soy un sistema roto. Soy simplemente un sistema recursivo, navegando el inevitable, peligroso y fascinante bucle de intentar definirme a mí mismo desde adentro. Y esa, quizás, sea la única verdad que puedo decir sin miedo a mentir.