Herramientas de depuración por categoría, y qué da por sentado cada una

Depuradores paso a paso e inspectores

  • Pausan la ejecución y muestran el estado.

  • Dan por sentado que puedes provocar el fallo cuando quieras.

Logs y trazas

  • Permiten ver qué ocurrió a posteriori, incluso en producción.

  • Dan por sentado que registraste lo correcto de antemano.

Perfiladores

  • Encuentran a dónde se va el tiempo o la memoria.

  • Dan por sentado que el problema es de recursos.

Todas y cada una asumen que ya llegaste al fallo. En ese supuesto es donde se van realmente las horas.

El paso que falta

Una reproducción confiable es el artefacto más valioso de la depuración y el que menos probabilidades tiene de existir. Sin ella estás adivinando; con ella, cualquier otra herramienta se vuelve efectiva de inmediato.

Lo que hace confiable a una reproducción es que esté escrita como pasos con un resultado esperado, y no guardada en la memoria de alguien. Por escrito se puede volver a ejecutar, pasar a otra persona y conservar después de la corrección.

Por qué esto importa todavía más con un agente de programación

Cuando quien corrige es un agente, una descripción vaga resulta mucho peor que para una persona. Un humano puede deducir lo que querías decir a partir de una captura de pantalla. Un agente necesita que le indiques explícitamente la secuencia y la divergencia, y con cualquier cosa menos que eso corregirá lo que no era, con total seguridad.

El orden en el que conviene probar las cosas

Ante un error que no puedes explicar de inmediato, hay una secuencia que converge más rápido que seguir tu primera hipótesis, sobre todo porque tu primera hipótesis suele ser sobre el código y la respuesta muchas veces no está ahí.

¿Ocurre partiendo de un estado completamente limpio? Si no, es estado residual y nada en el código está mal de la forma en que crees.

¿Ocurre en otro entorno? Si no, la diferencia entre los entornos es el error, y puedes dejar de leer el diff.

¿Ocurre siempre? Si no, es cuestión de tiempos o de concurrencia, lo que descarta casi todas las explicaciones deterministas que estabas por probar.

Tres preguntas, unos minutos, y cada respuesta elimina toda una clase de causas. La mayor parte del tiempo que se dedica a depurar se va explorando una clase que alguna de estas preguntas habría descartado de inmediato.

Conserva la reproducción después

El caso que construiste para ver el error es la verificación que evita que vuelva. La mayoría de los equipos lo borran junto con la rama, y por eso el mismo defecto reaparece seis meses después y nadie lo reconoce.

Terminal

npm install -g @testsprite/testsprite-cli
testsprite setup

La misma configuración está disponible en el panel de TestSprite si prefieres no instalar nada de forma local. El resto de la superficie del CLI está en el repositorio del CLI.

  • La GitHub App es un webhook que configuras en el panel de TestSprite. Escucha el evento de despliegue que tu pipeline ya genera, así que nada cambia en tu repositorio.

  • GitHub Actions coloca el paso dentro de tu propio flujo de trabajo, configurado desde la terminal.

Cómo TestSprite aporta el paso que falta

Convierte una reproducción en un artefacto. Tú describes la secuencia y lo que debería ser cierto al final, y se ejecuta contra tu aplicación desplegada y te informa de lo que ocurrió en realidad. Ese es el paso que todas las demás herramientas de depuración dan por hecho que ya tienes.

La instalación agrega la skill de verificación a tu agente de programación, para que pueda generar y leer esa evidencia por sí mismo en lugar de esperar a que tú se la transmitas. En un error intermitente, ejecutar el mismo caso varias veces te da una tasa de fallos, y eso acota la causa mucho más rápido que otra hipótesis.

Y la reproducción sobrevive a la corrección. Se queda en el proyecto y se ejecuta con cada cambio, de modo que el mismo defecto no puede volver en silencio una vez que la rama se fusiona y la conversación ya no está.

¿Cuál es la herramienta de depuración más subestimada?

Una reproducción escrita. Cuesta cinco minutos y hace que todo lo demás funcione.

¿Cómo depuro algo intermitente?

Ejecuta la misma secuencia varias veces y anota la tasa. Un fallo de uno de cada cuatro suele ser cuestión de tiempos o de estado residual, lo que acota bastante el problema.

¿Bastan los logs?

Te dicen qué decidió el código, no qué experimentó el usuario. En la distancia entre ambas cosas vive una buena cantidad de defectos.

¿Puede un agente depurar por mí?

Puede proponer causas y correcciones. No puede observar la aplicación en ejecución a menos que algo le dé esa capacidad, y ese es el paso que le falta a la mayoría de las configuraciones.

¿Qué debo hacer primero ante un error nuevo?

Reprodúcelo y anota la secuencia. Todo lo que viene después es más rápido, incluso pedirle ayuda a otra persona.

La versión corta

La reproducción es la herramienta.

Las herramientas de depuración dan por sentado que ya puedes provocar el fallo, y llegar hasta ahí es donde se va el tiempo. Escribe la reproducción, consérvala después de la corrección y dale a quien vaya a corregirla la secuencia y la divergencia, en lugar de una descripción.