Una IA puede preparar un cambio en pocos segundos. Revisarlo, mantenerlo y responder por él sigue llevando trabajo. Cuando ese cambio sale de nuestro repositorio y llega a un proyecto de software libre, parte de ese trabajo termina en manos de personas que no han participado en la conversación con el modelo.
Ahí es donde me parece que estamos calculando mal la productividad. Contar parches enviados no dice cuánto ha mejorado un proyecto. Si cada parche obliga a reconstruir el problema, comprobar una API inventada o preguntar qué se ha probado, hemos acelerado una parte y trasladado el coste a otra.
Podemos usar estas herramientas sin convertirnos en esa carga. Pero hay que empezar por las reglas del proyecto, no por el botón de crear una pull request.

Ilustración de GNU de Aurélio A. Heckert, © Free Software Foundation, bajo CC BY-SA 2.0.
Primero, comprobar si el proyecto acepta ese uso
Que el código tenga una licencia libre no significa que cualquier forma de generar una contribución esté aceptada. El repositorio puede exigir un procedimiento, unas pruebas y una declaración de procedencia. Todo eso forma parte de contribuir.
Antes de cambiar nada, abriría CONTRIBUTING, las instrucciones de desarrollo y la plantilla de pull requests. Si existe una política de IA, la leería antes de pedirle al modelo que escriba el parche. Si hay una duda importante sobre qué permite, conviene resolverla con los mantenedores, sin presentar la consulta como si ya hubieran aprobado el resultado.
Las diferencias entre proyectos son reales. La política de GCC rechaza por ahora contribuciones jurídicamente significativas que incluyan contenido generado por un LLM o derivado de él, con excepciones concretas, entre ellas casos de prueba. Permite distintos usos de investigación o análisis cuando la salida no se incorpora a la contribución.
El kernel de Linux tiene sus propias reglas para contenido generado, con requisitos de transparencia y responsabilidad humana. No es un permiso automático para cualquier cambio ni obliga a un mantenedor a aceptarlo.
Por eso no escribiría una regla universal de «si lo revisas, ya vale». Puede estar bien revisado y seguir incumpliendo la política del proyecto al que lo enviamos.
Elegir un problema pequeño que podamos explicar
Una contribución útil empieza con una necesidad concreta. Puede ser un error reproducible, una prueba que falta o una parte de la documentación que ya no corresponde al programa. No hace falta estrenar arquitectura para aportar algo.
Buscaría primero si hay una incidencia abierta o un cambio en marcha. Si otra persona ya está resolviendo el problema, quizá lo útil sea comprobar su solución y aportar un caso que falta. Crear otro parche equivalente sólo divide la revisión.
Imaginemos un paginador que pierde el último elemento cuando recibe una lista de longitud impar. Antes de tocar la implementación, necesitamos conocer la entrada, el resultado esperado y el resultado real. «La IA dice que esta función está mal» no sustituye esa descripción.
El cambio puede tener un objetivo tan pequeño como éste:
Entrada: cinco elementos, páginas de dos elementos.
Resultado esperado: tres páginas, sin perder ni duplicar elementos.
Resultado actual: el último elemento no aparece.
Alcance del parche: corregir ese caso y añadir una regresión.
Fuera de alcance: cambiar la API pública o reorganizar el módulo.
Con ese límite, es más fácil detectar si la herramienta se desvía. Si propone renombrar veinte clases, añadir una dependencia y cambiar los formatos de salida, está resolviendo algo distinto de lo que queríamos enviar.
Esa forma de delimitar el trabajo también aparece en el artículo sobre escribir especificaciones antes de programar con IA. Para un parche pequeño, bastan unas condiciones claras. No hace falta preparar una colección de documentos antes de corregir una línea.
Pedir análisis antes de pedir código
Una ayuda razonable es localizar por dónde pasa el dato, señalar las pruebas cercanas o proponer entradas que puedan demostrar el fallo. Eso no nos obliga a aceptar la primera explicación que aparezca.
Para este paso, una instrucción puede ser:
Busca dónde se construyen las páginas y qué pruebas cubren esa función.
Explica el recorrido usando archivos y funciones que existan en el repositorio.
No modifiques código todavía.
Separa lo que has encontrado de las hipótesis que habría que comprobar.
Después contrastamos la explicación con el código. Si menciona una función que no existe o atribuye el error a una dependencia que no se utiliza, no tiene sentido construir un parche encima de esa respuesta.
Tampoco enviaría al servicio de IA volcados de producción, tokens o conversaciones privadas de la incidencia. Un caso mínimo con datos inventados suele ser mejor para depurar y también más fácil de compartir en la revisión.
La prueba tiene que demostrar el problema
Una prueba que pasa con el código anterior y con el nuevo puede comprobar un comportamiento útil, pero no demuestra que hayamos corregido ese error. Para una regresión, necesitamos ver el fallo antes y el resultado correcto después.
Si el proyecto permite ese tipo de asistencia, la herramienta puede ayudar a plantear el test. Lo importante es revisar la expectativa, no sólo que se ejecute. Un test que copia la respuesta de la implementación como resultado esperado no aporta una comprobación independiente.
En el ejemplo del paginador, reconstruir la lista concatenando las páginas ofrece una condición fácil de entender. El orden y los elementos deben coincidir con la entrada. También podemos comprobar que ninguna página supera el tamaño solicitado y que los tamaños no válidos se rechazan según el contrato.
Cuando el fallo sólo aparece con una configuración determinada, esa condición debe quedar reflejada. No es lo mismo probar una función pura que levantar la aplicación con una base de datos concreta o ejecutar una ruta con permisos distintos.
Si el repositorio requiere servicios auxiliares, usaría su entorno de desarrollo documentado. No probaría un parche desconocido contra producción por ahorrar el tiempo de preparar ese entorno.
Leer el diff completo, no la explicación del agente
La explicación de una herramienta puede ser correcta y su parche contener cambios que no ha mencionado. Por eso leería el diff como si lo hubiera recibido de otra persona.
Podemos empezar con comprobaciones básicas:
git diff --stat
git diff --check
git diff
La primera muestra el alcance, la segunda encuentra determinados problemas de espacios y la tercera enseña el cambio. Ninguna certifica que el programa funcione. Son un punto de partida para una revisión que tiene que entrar en la lógica.
Miraría especialmente si ha cambiado el tratamiento de errores, si introduce una dependencia, si modifica permisos o si transforma una llamada local en una petición externa. También comprobaría archivos nuevos y cambios preparados en el índice, con git status --short y git diff --cached cuando corresponda.
Si la solución incluye una parte que no sabemos explicar, la reduciría o pediría ayuda antes de enviarla. Un parche pequeño y defendible tiene más posibilidades de ser útil que uno grande acompañado de una descripción muy convincente.
Ejecutar las pruebas que correspondan al cambio
Primero ejecutaría la prueba concreta del fallo. Después, las del módulo afectado y las comprobaciones que pide el proyecto. No podemos sustituir sus instrucciones por un comando genérico que sólo valida nuestro archivo.
También revisaría si la prueba se ha omitido por falta de una dependencia. Una salida sin errores no siempre significa que se haya ejecutado el caso que nos interesaba. El número de pruebas, los casos omitidos y el código de salida importan.
Si la modificación afecta a varias plataformas, conviene distinguir cuáles se han comprobado. No presentaría una prueba en Linux como validación de Windows, ni una compilación correcta como demostración de que una carrera entre hilos ha desaparecido.
Hay una diferencia importante entre «no puedo completar esta comprobación en mi entorno» y «todo está verificado». En una contribución técnica, explicar el alcance ayuda a que otra persona complete la parte que falta sin repetir el trabajo entero.
Explicar procedencia y responsabilidad según sus reglas
Las instrucciones del kernel para asistentes de código distinguen la ayuda de la herramienta de la responsabilidad de quien presenta el cambio. Los agentes no deben añadir su propio Signed-off-by, y la asistencia sustancial se documenta conforme a esas instrucciones.
El Developer Certificate of Origin no es una firma decorativa. Quien lo utiliza está certificando unas condiciones sobre la contribución y su derecho a presentarla. No lo añadiría por copiar una plantilla sin entender qué afirma.
Cada proyecto puede pedir campos diferentes. Hay que usar su formato, no inventar una declaración común para todos. Esto tampoco se resuelve preguntándole a la IA si su salida tiene una licencia compatible. La respuesta del modelo no constituye una comprobación del origen del código.
En la descripción del cambio dejaría claro el problema, por qué se produce, cómo lo corrige el parche y qué pruebas se han ejecutado. Si su política exige explicar la ayuda utilizada, esa información debe ser concreta y proporcionada, no una lista de herramientas sin relación con el cambio.
Después del envío, el trabajo no ha terminado
Una pull request no es una entrega que desaparece de nuestra lista. Puede recibir preguntas sobre compatibilidad, diseño o una alternativa más sencilla. Hay que responder leyendo el comentario y el código, no dejando que el agente conteste automáticamente a un mantenedor.
Si el proyecto rechaza el enfoque, intentaría entender qué restricción no habíamos considerado. Puede que la corrección esté bien, pero no encaje con la API que quieren conservar o con el coste de mantenimiento que pueden asumir.
Para mí, contribuir con IA tiene sentido cuando facilita ese proceso: entender antes el problema, encontrar mejores casos de prueba y preparar un cambio más claro. Si sólo sirve para enviar más código del que podemos revisar, estamos confundiendo actividad con ayuda.
El objetivo sigue siendo dejar el proyecto un poco mejor y hacerle más fácil el trabajo a quien venga después. La herramienta puede acelerar algunos pasos. La responsabilidad de la contribución no se delega con el prompt.
