Soy de los que creen que los devs estamos en una eterna etapa de aprendizaje. Si, nunca se deja de aprender. Ya sea a través de libros, cursos online o, claro, con las dosis épicas de errores que siempre terminan haciéndonos sudar frío. Esos bugs, esos errores que parecen tener un radar para aparecer justo cuando menos los necesitamos, acechando, listos para desmoronarnos, como si nuestro pc tuviera una especie de venganza personal contra nosotros. Si alguna vez te has encontrado mirando una pantalla de error, con el estómago en un nudo, seguro sabes de lo que hablo. Pero, ¿y si pudiera hacer algo con esos errores? ¿Y si pudiera enseñar a una IA a aprender de ellos, a entender qué es lo que siempre hago mal y, por qué no, ayudarme a corregirlos antes de que se me escapen? Pues bien, me lancé a este experimento y, como siempre, los resultados fueron tan interesantes como sorprendentes. Así que, te invito a acompáñame a ver qué pasó cuando intenté entrenar una IA para que se convirtiera en mi nuevo compañero de depuración.
Spoiler: no fue tan fácil como esperaba, pero al final, valió la pena.
¿Qué pasa si entreno una IA con los errores que cometo más a menudo?
Seguro que más de uno se ha sentido alguna vez como yo: miras tu código y no tienes ni idea de por dónde empezar a depurar. Y lo peor de todo es que, si eres como yo, terminas cometiendo los mismos errores una y otra vez. Vamos, no soy el único, ¿verdad? Mi teoría, y el experimento, es que si entreno una IA con estos errores, podría ayudarme a identificar mis patrones de “dramas” antes de que yo mismo los vea. Suena bien, ¿no?
A lo largo del tiempo, he descubierto que siempre cometo los mismos fallos, soy animal de costumbres. Entre los clásicos destaco: un NoneType donde debería haber un diccionario, olvidarme de cerrar las llaves de un JSON, o un bucle infinito que termina haciendo que el sistema se desespere buscando un break como el comer. Así que, pensé, ¿por qué no aprovechar toda esta experiencia (y lloros) para enseñarle a la IA a detectar esos fallos antes de que los vea yo?
Lo curioso es que, aunque la teoría suena bien, ponerla en práctica no es tan sencillo como yo pensaba. A veces me encuentro preguntándome si mi editor de código realmente tiene algo en contra de mí. Pero, dejando las paranoias a un lado, me di cuenta de que este patrón de errores repetitivos era un campo de entrenamiento perfecto para una IA. Así que me lancé al experimento: entrenar a una inteligencia artificial con ejemplos de mis bugs más comunes. Lo que tenía en mente era que la IA pudiera aprender no solo a reconocer el error, sino también a anticiparse a él y darme pistas antes de que el código explotase. Básicamente, convertir la IA en un compañero de debugging que, en lugar de solo decirme qué falló, pudiera prevenir esos tropiezos antes de que ocurrieran. Y si soy sincero, no sabía si mi experimento iba a ser un éxito rotundo o simplemente una excusa más para seguir procrastinando. Seguimos.
Cómo recolecté mis bugs frecuentes
Reunir los bugs más comunes no fue una tarea tan fácil como esperaba, porque seamos sinceros: soy un desastre organizando registros de errores. Y no, no estoy exagerando. Hay días en que, entre tanto código, logs abiertos y sesiones de debugging (que, por cierto, nunca se cierran cuando debería), parece que tengo más errores que código funcional. Pero bueno, esa es la realidad de todo programador, ¿verdad?
Así que, decidí hacer una limpieza profunda. Comencé por organizar mi memoria (y mis archivos) para darme cuenta de cuáles eran los fallos más recurrentes. Claro, como siempre tengo un montón de logs abiertos — esos que sólo cerramos cuando el sistema ya está al borde del ko — aproveché para hacer un repaso.
Una vez que tuve claro cuáles eran mis errores más frecuentes, me puse a organizarlos en ejemplos concretos para entrenar a la IA. Pero aquí viene lo interesante: no solo me limité a copiar y pegar los mensajes de error que aparecían. En lugar de solo enfocarme en la típica advertencia de “NoneType no tiene atributo ‘algo’”, me fijé también en los patrones que se escondían detrás de cada error. Por ejemplo:
- Falta de validación en entradas de usuario: Si un campo de un formulario no se valida correctamente, sabes que algo va a fallar. Lo curioso es que en la mayoría de los casos, el código sigue ejecutándose hasta que algo mucho más grande revienta.
- Mala gestión de excepciones: Si no atrapamos las excepciones de manera adecuada, puede que un error aparentemente inofensivo termine causando un crash en toda la aplicación. Aquí los errores de tipo “KeyError” o “IndexError” se hacen frecuentes si no estamos atentos.
- Variables no inicializadas: Siempre he sido muy fan de las variables que se olvidan de ser inicializadas. Y no, no es un amor muy correspondido, porque el código se da cuenta antes que yo y me lanza un error.
- Faltas en la estructura de datos: A veces, uno da por hecho que un diccionario o lista va a contener lo que necesita y, cuando no es así, el código se vuelve completamente loco.
Lo interesante de todo esto es que no me quedé solo con los mensajes de error. Traté de entender el contexto en el que ocurrían y qué causaba que esos errores aparecieran en primer lugar. Eso me dio una perspectiva más amplia para enseñar a la IA cómo detectar estos fallos no solo cuando suceden, sino antes de que puedan romper el flujo del código.
Es como si estuviera entrenando a mi IA para que no solo identificara errores, sino que se volviera tan lista como para anticiparlos antes de que yo los vea. Así que, aunque mi enfoque era simple — tomar los errores y enseñarle a la IA a reconocerlos — traté de ir más allá y mostrarle el “por qué” detrás de cada fallo. Al fin y al cabo, si quieres que una IA sea útil, no basta con enseñarle lo que ya sabes, hay que darle contexto, y cuanto más, mejor.
Fine-tuning de un LLM ligero: LLaMA 3
Aquí empezó lo realmente divertido. Elegí un modelo ligero, como LLaMA 3 (sí, ya sé, el nombre suena más a héroe de cómic que a modelo de IA, pero qué le vamos a hacer).
Estos modelos, aunque no son los más potentes, son perfectos para estos experimentos porque pueden aprender de ejemplos personalizados sin necesitar recursos infinitos. Si voy a meterme en este lío, al menos que sea con algo que no sea un monstruo devorador de recursos. Y la verdad, me sorprendió lo rápido que comenzaron a adaptarse.
El proceso de fine-tuning fue bastante directo. Tomé los ejemplos de errores y el modelo empezó a analizar los patrones que se repetían. En pocos días, la IA ya era capaz de predecir ciertos errores con una precisión que, para mi sorpresa, no estaba nada mal. Es como si la IA estuviera diciendo: “Ah, Juan, ya sé por dónde vas, ¿quieres que te avise antes de que rompas todo?” Y, sinceramente, esa sensación de tener una especie de compañero invisible que te da un toque de atención es oro. Y mola, además.
A medida que el modelo aprendía, me di cuenta de lo impresionante que era identificar esos patrones ocultos.
Por ejemplo, en un proyecto reciente, estaba lidiando con un error clásico: un NoneType que se encontraba en una lista cuando se esperaba un diccionario. Es algo que suelo pasar por alto, pero la IA ya me lo señaló antes de que pudiera seguir escribiendo más código. Como si me hubiera dicho: “Oye,Juan, revisa bien esa variable, creo que te estás olvidando de algo clave.” Y lo mejor fue que no solo lo señaló, sino que me ofreció una sugerencia de validación para evitar el problema. Not bad.
Resultados y errores comunes que ahora detecta
Y ahora, ¿qué tal ha funcionado todo esto? Pues, para ser honesto, no es que la IA esté escribiendo el código por mí, pero me está ayudando bastante. Ahora, puedo detectar errores que antes hubiera dejado pasar, como:
- Detectar variables no inicializadas antes de que exploten mi código (esos errores son mi pesadilla diaria). De hecho, el otro día, la IA me avisó justo antes de que se diera un error de NameError porque una variable config no estaba inicializada antes de usarla en una función. Un clásico.
- Avisarme cuando una función tiene demasiados parámetros (sí, a veces me paso de la raya y meto tantos parámetros que parece un chiste). El modelo me señaló una función que tenía más de 8 parámetros, sugiriendo que tal vez debería considerar la opción de refactorizarla para mejorar la legibilidad del código.
- Sugerir validaciones para las entradas de los usuarios, evitando que esas pequeñas caídas por mal manejo de excepciones me pillen desprevenido. Me recordó que debería validar los inputs de una API antes de procesarlos, algo que, sinceramente, había pasado por alto varias veces. Esas pequeñas validaciones hacen una gran diferencia.
Y lo mejor de todo es que también me ha detectado cosas que ni siquiera sabía que hacía mal, como referencias a objetos que deberían haber sido inmutables. El otro día me sorprendió al señalarme que estaba modificando una lista dentro de un diccionario sin darme cuenta de que estaba alterando el objeto original. Debería haber hecho una copia profunda. La IA fue más allá de los errores comunes que yo esperaba encontrar, y me hizo darme cuenta de detalles como este, que a menudo no saltan en las pruebas unitarias.
En resumen, la IA no solo me está ayudando a detectar esos bugs comunes, sino que también me está enseñando nuevas formas de mejorar mi código, de una manera que nunca imaginé antes de este experimento.
Reflexión: ¿Vale la pena afinar la IA con tu estilo?
Mi sentido arácnido me dice que este NoneType viene a romper todo otra vez…”
Aquí viene la pregunta del millón: ¿realmente vale la pena pasar tiempo entrenando una IA con mis propios errores?
La respuesta corta es: sí.
La larga, como buena gallego es: depende.
Y es que, más allá de lo que uno podría pensar al principio, no se trata de poner toda tu fe en que la IA haga todo el trabajo. Si alguna vez te has enfrentado a esos bugs que parecen imposibles de encontrar, sabes lo útil que puede ser una alerta temprana. La IA no te da las respuestas mágicas, pero te ayuda a ver patrones, y eso te permite corregir a tiempo.
A medida que el modelo se va entrenando, cada vez es más capaz de detectar esos pequeños detalles que uno suele pasar por alto. Cosas tan simples como una variable mal nombrada o una validación que nunca se hizo. Son detalles que, aunque parecen insignificantes, pueden ahorrarte horas de trabajo y frustración. Es como si la IA te estuviera enseñando a mejorar tu proceso de depuración, aprendiendo de tus propios tropiezos y ayudándote a anticiparlos. Sin duda, el proceso de mejorar el modelo no reemplaza el trabajo que uno debe hacer para entender lo que está ocurriendo en el código, pero definitivamente ayuda a reducir esos momentos de desesperación en los que te preguntas “¿por qué no vi esto antes?”
Claro, hay límites. La IA no va a encontrar todos mis bugs (y probablemente nunca lo haga). No tiene la capacidad de entender a fondo todas las complejidades que un humano podría analizar, como la lógica detrás de ciertas decisiones o las interacciones complejas entre varias partes del código. Pero lo que sí ha logrado es enseñarme más sobre mis propios errores y cómo evitar caer en ellos una y otra vez. Al final, no se trata solo de corregir lo que la IA encuentra, sino de usarla como una herramienta para ser más consciente de tus propios patrones de error. Y eso, amigos, es algo que no se compra ni con todo el café del mundo, ni con un par de terminales abiertos a lo loco.
Si bien la IA no es infalible, el aprendizaje que ofrece, tanto a nivel técnico como a nivel de mejora personal, es invaluable. Y si logras que te ayude a corregir esos pequeños detalles que a menudo se nos pasan por alto, ya habrás ganado una gran ventaja. Así que, aunque no reemplazará nunca a la mente humana, sí puede ser el compañero perfecto para aquellos días en los que las horas de debugging se sienten interminables.
Uso el análisis de datos para fortalecer la toma de decisiones y mejorar la implementación de inteligencia artificial. Te ayudo a convertir la información en una ventaja competitiva real para tu negocio, combinando tecnología y estrategia para generar impacto y maximizar oportunidades.
