Cuando se empieza a trabajar con inteligencia artificial para tareas de desarrollo, un prompt sencillo suele bastar. Se define un rol, una tarea, un formato de salida y algunas restricciones. Con eso es suficiente para revisiones rápidas: explicar un error, sugerir un plan o limpiar una nota. Pero en cuanto las peticiones se acercan al trabajo real de ingeniería —como revisar un pull request antes de fusionarlo— la simplicidad se desvanece. Una revisión útil tiene que leer el cambio, entender la intención, detectar contextos faltantes, separar riesgos graves de sugerencias menores, pensar en pruebas y entregar un resultado accionable. Al principio se tiende a añadir más reglas al prompt. Si la IA salta a una solución demasiado rápido, se agrega una regla sobre entender primero el límite de la tarea. Si mezcla bloqueos con comentarios de estilo, se añade una regla de priorización. Si suena segura sin suficientes pruebas, otra regla sobre evidencia. Si la respuesta es técnicamente correcta pero difícil de leer, se incorpora una regla sobre el formato final. Cada regla tiene sentido. El problema es la forma del conjunto. El prompt se convierte en una larga instrucción donde todo vive en un mismo flujo: análisis de entrada, revisión de implementación, arquitectura, riesgo, pruebas y redacción final. La salida puede parecer pulida, pero los controles reales son difíciles de ver.

Ese es el punto en el que muchos equipos dejan de tratar el prompt como un gran texto y empiezan a tratarlo como un pequeño proceso. Una habilidad de IA, entendida como un flujo de trabajo repetible para un tipo de tarea, puede adoptar muchas formas: un skill de Codex, un asistente personalizado, un prompt de sistema, un conjunto de reglas de repositorio, etc. La herramienta importa menos que el patrón: el usuario trae un tipo de tarea recurrente, y la IA la maneja de manera predecible. Para tareas muy pequeñas, un prompt corto suele funcionar. Pero para trabajo recurrente de desarrollo, el prompt empieza a cargar más responsabilidad. Tiene que saber qué cuenta como entrada, qué cuenta como riesgo, qué necesita una prueba, qué puede bloquear el trabajo y cómo la respuesta final debe ayudar al humano a tomar una decisión. La solución natural es dividir esas responsabilidades dentro de la misma habilidad. El usuario sigue hablando con una única habilidad de IA y recibe una respuesta. Internamente, la tarea se maneja como varios tipos de trabajo.

El problema de un prompt grande es que a menudo crece a partir de correcciones útiles. La IA pierde contexto, así que añadimos una regla de contexto. Ignora un riesgo, añadimos una regla de riesgo. Escribe consejos vagos, añadimos una regla de salida. Olvida las pruebas, añadimos una regla de verificación. Al cabo de un rato, el prompt contiene muchas reglas buenas, pero la IA aún tiene que usarlas todas a la vez. Para una revisión de código, eso significa que en una sola pasada se espera: leer el diff, inferir la intención, notar información faltante, entender la implementación, comprobar el posible impacto en el usuario, pensar en permisos, datos, compatibilidad y caminos de fallo, decidir qué bloquea la fusión, sugerir pruebas y escribir una revisión clara. Es mucho trabajo oculto detrás de una respuesta suave. La revisión puede sonar razonable, pero el desarrollador aún tiene que preguntarse: ¿qué comentarios son bloqueantes? ¿cuáles son sugerencias? ¿qué trató la IA como un hecho? ¿qué es solo una suposición? ¿qué debería probarse antes de fusionar? ¿es la conclusión lo suficientemente sólida para actuar? Cuando esas preguntas no son visibles en la estructura, la respuesta de la IA se vuelve menos útil como herramienta de ingeniería.

La separación de responsabilidades consiste en dividir el trabajo en roles dentro de la misma habilidad de IA. Para tareas de desarrollador, las responsabilidades suelen incluir: ingesta de entrada (qué se proporcionó, qué falta y qué no se puede asumir), revisión de implementación (si el cambio resuelve el problema planteado), planificación de acciones (cuál debería ser el siguiente paso útil más pequeño), revisión de riesgos (datos, permisos, compatibilidad, acciones irreversibles, impacto en el usuario), control de calidad (pruebas, reproducción, evidencia, verificación manual, incertidumbre) y edición final (una respuesta concisa sobre la que el desarrollador pueda actuar). Esto sigue siendo una única habilidad. El usuario no debería tener que leer seis informes separados. El objetivo es hacer más claro el trabajo interno. La respuesta final puede ser corta, pero debe llevar el resultado de estas comprobaciones: qué se sabe, qué es arriesgado, qué bloquea la decisión, qué necesita verificación y qué puede esperar.

Pongamos un ejemplo con una petición pequeña: 'Revisa este pull request antes de fusionar'. Una revisión débil de IA podría enumerar: 'Considera renombrar esta variable. Quizás añadir una prueba. Comprobar el manejo de permisos. El código podría ser más legible'. Cada línea es plausible, pero juntas no ayudan mucho. Un comentario de estilo, una prueba faltante, un posible problema de permisos y una nota de legibilidad tienen el mismo peso. El autor del pull request aún tiene que decidir qué es importante antes de fusionar. Con una separación de responsabilidades, la misma revisión puede volverse mucho más práctica. La ingesta de entrada comprueba si la IA tiene el diff, la descripción de la tarea y las restricciones. La revisión de implementación verifica si el cambio resuelve el problema real. La revisión de riesgos busca casos donde un cambio pequeño pueda afectar a usuarios, datos, permisos o compatibilidad. El control de calidad pregunta cómo se puede verificar la conclusión. La respuesta final podría ser: 'Bloqueantes: después de un fallo de autorización, el código puede devolver un resultado en caché. Esto puede mostrar datos obsoletos o no autorizados al usuario actual. Preguntas: ¿hay una prueba para la ruta de fallo de autorización? Sugerencias: mantener la caída a caché para fallos técnicos, pero manejar la denegación de acceso como una parada dura. Conclusión: no fusionaría este PR todavía. Primero, hacer explícita la ruta de fallo de autorización y cubrirla con una prueba'. El valor viene del orden, no de hacer la respuesta más larga. El problema importante tiene un lugar claro. La pregunta está separada de la recomendación. La sugerencia no oculta el bloqueante. La conclusión le dice al desarrollador qué decisión apoya la revisión.

El mismo patrón se aplica al triaje de bugs. Cuando la petición es 'Aquí hay un error, arréglalo', la IA a menudo salta directamente al archivo probable y sugiere un parche. Eso puede ser útil para problemas obvios. Para un bug real, el trabajo útil suele empezar un paso antes. La ingesta de entrada separa hechos de conjeturas: ¿qué ocurrió exactamente? ¿hay un stack trace? ¿se puede reproducir el problema? ¿qué entorno y versión están implicados? ¿qué se ha comprobado ya? La revisión de implementación busca el área probable de la causa. La planificación de acciones elige un camino pequeño a través del código en lugar de convertir el bug en una refactorización amplia. La revisión de riesgos pregunta si el arreglo toca datos, permisos, migraciones, APIs públicas, trabajos en segundo plano o comportamiento en producción. El control de calidad pregunta cómo demostrar el arreglo: una prueba que falle antes del cambio, la misma prueba que pase después, un comando de reproducción, una comprobación manual, una nota clara sobre lo que no se pudo verificar. La respuesta final puede ser compacta: debe decirle al desarrollador la causa, el cambio, la verificación y el riesgo restante. Eso es lo que un ingeniero experimentado suele mantener en su cabeza. La habilidad solo lo hace explícito para que la IA lo siga.

¿Por qué ayuda esto? El primer beneficio es menos suposiciones ocultas. Cuando la habilidad tiene un paso de entrada, es más probable que diga lo que falta antes de escribir una respuesta segura. Eso importa en la revisión de código y el triaje de bugs, porque una suposición segura puede hacer perder más tiempo que una pregunta honesta. El segundo beneficio es una mejor priorización. Una revisión útil es más que una lista de posibles mejoras. Le dice al desarrollador qué bloquea la decisión, qué necesita una respuesta y qué es solo una sugerencia. El tercer beneficio es una mejora más fácil de la propia habilidad. Si todas las reglas viven en un solo prompt grande, es difícil ver qué falló. ¿La IA perdió el límite de entrada? ¿No vio el riesgo? ¿No pidió evidencia? ¿Escribió una buena respuesta técnica en un mal formato? Cuando las responsabilidades están separadas, la siguiente edición es más dirigida. Si la IA inventa hechos faltantes, se mejora la ingesta de entrada. Si pasa por alto riesgos de permisos, se mejora la revisión de riesgos. Si da respuestas largas y desenfocadas, se mejora la edición final. La habilidad puede crecer donde realmente falla.

Este enfoque resulta especialmente valioso cuando se integra en flujos de desarrollo profesionales. En Q2BSTUDIO, entendemos que la calidad del código y la seguridad son pilares de cualquier proyecto. Por eso, al ofrecer servicios de aplicaciones a medida, aplicamos metodologías que incluyen revisiones de código asistidas por IA con separación de responsabilidades. No se trata solo de usar inteligencia artificial, sino de estructurarla para que sus respuestas sean accionables y fiables. Cuando trabajamos con ia para empresas, diseñamos agentes IA que no solo responden, sino que siguen procesos internos claros: ingesta, análisis, riesgo, calidad y acción. Eso permite que equipos de desarrollo y negocio tomen decisiones informadas sin perder tiempo interpretando salidas ambiguas. Del mismo modo, en proyectos de servicios cloud aws y azure, aplicamos este tipo de patrones para revisar cambios en infraestructura, evaluar riesgos de compatibilidad y asegurar que cada despliegue cumpla con los estándares de ciberseguridad. La inteligencia artificial no reemplaza el juicio humano, pero puede estructurarlo para que sea más eficiente.

¿Cuándo usar esta estructura? Es ideal para tareas donde la respuesta apoya una decisión: fusionar o retener un pull request, cambiar una API pública, arreglar un bug con causa poco clara, preparar un check de release, tocar datos de usuario o permisos, transferir una tarea larga a otra sesión o persona, o revisar material que se publicará. Para peticiones pequeñas, la estructura se vuelve peso extra. Si solo se necesita un comando Git, una explicación rápida de un error de compilador o un pequeño ejemplo de código, un proceso completo de revisión estorba. La habilidad debe ajustarse al peso de la tarea. También existe un modo de fallo en la dirección opuesta: roles que se repiten entre sí. Si cada rol dice lo mismo, el resultado es solo ruido. Cada responsabilidad debe atrapar un tipo diferente de problema o tomar una decisión diferente.

En la práctica, este enfoque de 'prompt como proceso' es el que aplicamos en Q2BSTUDIO para nuestros desarrollos. Ya sea creando software a medida, implementando soluciones de servicios inteligencia de negocio con Power BI, o automatizando procesos mediante agentes IA, la claridad en la revisión y el triaje es fundamental. No se trata de tener un prompt perfecto, sino de construir pequeñas máquinas de proceso que operen de forma predecible. El usuario sigue siendo el dueño de la decisión. La IA sigue cometiendo errores. Pero el trabajo es menos opaco. Para nosotros, ese es el camino hacia una inteligencia artificial realmente útil en el día a día del desarrollo y la empresa. ¿Cómo estructuras tú la revisión asistida por IA o el triaje de bugs en tu flujo de trabajo?