Programación
Mejora una herramienta de pruebas de mutación según su código y pruebas actuales
Para modificar una herramienta de pruebas de mutación. Revisa primero el código y las pruebas actuales, conserva el orden de procesamiento y la evaluación diferida, crea mutadores sin mutantes inválidos, escribe pruebas que los detecten y sigue pasos seguros de revisión, CI y publicación.
Añade funciones a una app de escritorio por capas y prueba cada compilación
Úsalo cuando una IA cambie una app de escritorio con núcleo, host de escritorio e interfaz web. Deja las reglas en el núcleo, limita los comandos y carpetas de las herramientas, separa las funciones opcionales por sus dependencias reales y prueba cada compilación antes de terminar.
Encontrar errores reales en parches de sistemas de bajo nivel, sin quejas de estilo
Úsalo al revisar parches de sistemas de bajo nivel, como drivers o bibliotecas de red. Sigue la memoria, los locks y las rutas de error, revisa enteros, hilos, criptografía y cambios de API, e informa solo de fallos corregibles; el estilo, solo si está muy seguro.
Añade funcionalidades a un servicio Go extensible con pruebas que resistan la sobrescritura de la configuración
Para cambiar un servicio Go que otras compilaciones renombran o personalizan. Mantiene el contexto de trazas en los logs, registra las herramientas nuevas en el grupo correcto, prueba el comportamiento público con configuración sobrescrita y actualiza la documentación generada.
Imita el comportamiento de otro framework web con una capa de compatibilidad
Úsalo al reimplementar otro framework web en varios entornos. La IA porta primero sus pruebas, respeta el orden de las solicitudes y los límites entre entornos, normaliza las rutas de archivos y solo fusiona con pull requests que pasan todas las comprobaciones.
Cambiar un envoltorio administrado y su biblioteca nativa sin romper la ABI
Para editar un envoltorio administrado multiplataforma sobre una biblioteca C nativa. Sigue cada cambio por cada capa, compila binarios nativos desde la fuente sin descargas obsoletas, mantiene estable la ABI pública, gestiona la propiedad de punteros e hilos y no omite pruebas fallidas.
Añade y prueba kernels en una biblioteca de kernels de GPU con compilación JIT
Úsala cuando una IA trabaje en una biblioteca de kernels de GPU compilados al usarse (JIT). Añade kernels por todas las capas, escribe lo generado solo en carpetas con escritura, prueba por tipo de GPU y comprueba resultados antes de medir la velocidad.
Cambia y revisa una pasarela de integración multiprotocolo sin romper los controles de acceso
Úsalo cuando una IA cambie o revise una pasarela que une varios protocolos. Pasa las comprobaciones del proyecto, mantiene estrictos los permisos, separa las escrituras de trazas y auditoría, cuida las migraciones y pide aprobación antes de hacer push.
Crear servicios Rust asíncronos que resistan cancelaciones y fallos
Para servicios Rust asíncronos: la IA termina el código real sin simulaciones, maneja errores y cancelaciones con seguridad, prueba a través de la interfaz real del servicio y pasa todas las comprobaciones antes de darlo por terminado.
Modificar una biblioteca de datos multilingüe sin romper sus formatos de archivo ni sus API
Úsalo cuando una IA modifica una biblioteca de datos rápida con un núcleo nativo y enlaces de lenguaje ligeros. Mantiene compatibles los formatos de archivo estables y las API públicas, usa los comandos documentados y añade pruebas y documentación.
Crear código de replicación de datos (ETL) que no cambie valores en silencio ni filtre datos
Úsalo al crear o cambiar código que copia datos entre bases de datos. Mantiene los cambios pequeños, evita redondeos y otros cambios silenciosos, devuelve errores claros ante entradas malas, no registra secretos ni filas en los logs y comprueba que las pruebas se ejecutaron.
Modificar una herramienta de automatización de dispositivos y comprobarla en dispositivos reales
Úsalo cuando una IA modifica una herramienta multiplataforma de automatización de dispositivos. Hace cambios pequeños, reúne los datos de comandos en un registro, elige pruebas según el cambio y comprueba con compilaciones nuevas en dispositivos reales o simuladores antes de informar.
Cambiar un monorrepositorio grande y tipado sin romper otros paquetes
Úsalo cuando una IA edita código con varios paquetes. Busca el paquete responsable del cambio, reutiliza las utilidades compartidas, sigue las reglas de compilación y tipos, prueba solo los paquetes afectados e informa solo de lo que se comprobó de verdad.
Modifica un motor de almacenamiento de bases de datos sin perder velocidad ni compatibilidad
Úsalo cuando una IA modifique un motor de almacenamiento de bases de datos. Cuida los errores y la concurrencia, acelera el código más usado solo con pruebas comparativas, mantiene compatibles las API, los formatos y las compilaciones, y exige pruebas reproducibles antes de aprobar.
Desarrollar una CLI multiplataforma en un árbol de trabajo compartido sin estropear el trabajo ajeno
Para crear una CLI en un árbol de trabajo compartido con otras sesiones. Trabaja solo en el árbol actual, conserva los cambios ajenos, separa los datos de los mensajes para personas, prueba en todos los sistemas y mantiene al día instantáneas y documentación.
Crear una herramienta de contenedores sin root, con bloqueos y descargas de imágenes verificadas
Úsalo al crear una herramienta de contenedores sin root. La IA bloquea los contenedores al cambiarlos, verifica cada capa de imagen descargada, no copia el entorno del host, detiene árboles de procesos completos y rechaza rutas peligrosas al restaurar copias.
Crea una herramienta que revisa y corrige código con IA sin perder el código del usuario
Úsala al trabajar en una herramienta que revisa y corrige código con IA en segundo plano. Lee antes la build y los documentos de responsables, impide que ramas no fiables ejecuten comandos, protege los trabajos activos y frena pushes o releases inseguros.
Escribir habilidades para agentes de IA y comprobar que de verdad ayudan
Para añadir o actualizar habilidades en una biblioteca de habilidades para agentes de IA. Cubre nombres y versiones, descripciones que se activan en el momento justo, permisos mínimos de herramientas, pruebas con y sin la habilidad y revisiones previas a publicar.
Hacer cambios pequeños y con pruebas en el monorepositorio de un framework
Úsalo cuando una IA modifica código en el monorepositorio de un framework. Busca primero los archivos de guía principales, limita cada cambio a un comportamiento, escribe una prueba que falle antes de corregir y revisa la seguridad, la compilación y las notas de versión.
Cambiar un gran monorepositorio de flujos de trabajo en Python sin romperlo
Úsalo cuando una IA edita un gran monorepositorio Python de flujos de trabajo. Separa los papeles del planificador, los procesos de trabajo y la base de datos, pone cada dependencia en su paquete, prueba primero lo cambiado y revisa el diff completo antes de la solicitud de incorporación.
Cambiar a la vez las versiones síncrona y asíncrona de una biblioteca cliente sin romper su API
Úsalo cuando una IA cambie una biblioteca cliente con clientes síncrono y asíncrono. Mantiene las API públicas y los errores, aplica el mismo cambio en ambos lados, no ralentiza las rutas críticas y prueba desde un caso fallido hasta la matriz completa.
Crear un servicio de memoria para agentes de IA sin mezclar los recuerdos de cada usuario
Úsalo al crear o ampliar la memoria a largo plazo de agentes de IA. Separa cada banco de memoria, distingue ingesta, recuperación y razonamiento, y cubre migraciones de base de datos, clientes de API, pruebas juzgadas por otro modelo y ajustes por inquilino o banco.
Modificar el monorepositorio de una plataforma de trabajos distribuidos y probarlo con servicios reales
Úsalo cuando una IA modifique un monorepositorio de trabajos distribuidos. Elige la comprobación adecuada para cada paquete, prueba con bases de datos y colas reales, registra los cambios publicados, ejecuta en local una tarea completa e informa de qué se comprobó y qué se omitió.
Crear módulos .NET con diseño guiado por el dominio (DDD) sin romper capas ni API públicas
Úsalo cuando una IA cambie una aplicación .NET modular con diseño guiado por el dominio. Sigue los patrones existentes, mantiene las capas en un solo sentido, ubica agregados, repositorios y DTO en su capa y prueba en todas las bases de datos sin afectar a los usuarios actuales.
Modificar una extensión para varios navegadores sin filtrar secretos ni romper los datos guardados
Úsalo al cambiar una extensión que se publica en varios navegadores. Guarda los secretos en local, regenera las políticas de dependencias, añade actualizaciones numeradas para los datos guardados, prueba en la capa adecuada y usa Git solo cuando se pide.
Modificar código distribuido de entrenamiento e inferencia de aprendizaje automático sin romperlo
Para cambiar software que entrena o ejecuta modelos de aprendizaje automático en muchos procesos o aceleradores. Consulta antes de cambios riesgosos, alinea versiones de pesos y orden de operaciones colectivas en cada rango, mantiene compatible la configuración y reporta pruebas omitidas.
Desarrollar una app web que muestra en vivo los registros y métricas de contenedores
Úsalo al cambiar una aplicación con backend y frontend que transmite registros y métricas de contenedores. Respeta las capas, los límites de flujo y los modos de acceso y despliegue, añade funciones en todas las capas, ejecuta las pruebas y escribe revisiones breves.
Cambiar un paquete de servidor público que otros amplían sin romper su código
Úsalo al cambiar un paquete de servidor publicado que otros amplían con hooks. Deja fuera los secretos, mantiene los callbacks, los hooks y el orden del middleware, añade migraciones nuevas en vez de editar las antiguas y ejecuta las pruebas y el lint reales.
Modifica un proyecto C portable y veterano sin romper la compatibilidad
Úsalo si una IA cambia código C maduro que debe seguir compilando con compiladores antiguos, muchas plataformas y funciones opcionales. Compila y prueba lo afectado, sigue las reglas de estilo, memoria, commits, documentación y versiones, y deja cada parche pequeño y válido por sí solo.
Modificar un repositorio de backend y frontend con varios módulos sin romper la compilación
Úselo cuando una IA modifique un repositorio con API, backend y frontend juntos. Lee las reglas de cada módulo, mantiene ambos lados alineados, regenera el cliente de la API en vez de editarlo a mano, ejecuta las pruebas adecuadas y pregunta antes de migraciones o nuevas dependencias.
Modifica un gran monorepositorio de plataforma de datos multilingüe y prepara pull requests
Úsalo cuando una IA edite una gran plataforma de datos en varios lenguajes. Elige la rama de Git correcta, no edita a mano archivos generados, usa la base de pruebas mínima, prueba solo lo cambiado, revisa cada fallo de CI y pide permiso antes de hacer push o abrir pull requests.
Crear y revisar automatización de infraestructura con Ansible sin debilitar la seguridad
Úsalo cuando una IA escriba o cambie automatización de infraestructura con Ansible. Pasa los lint y controles de seguridad sin advertencias, deja los secretos fuera del repositorio, revisa la red de abajo arriba, demuestra que las pruebas detectan el fallo e informa solo de lo ejecutado.
Cambiar un gran sistema de datos en Python sin romper la ejecución diferida
Úsalo cuando una IA cambie un gran sistema de datos o de cálculo paralelo en Python. Ubica primero las capas, no ejecuta cálculos al construir grafos, prueba desde lo más cercano hacia fuera y nunca publica versiones ni paquetes sin permiso.
Escribir primero la especificación y luego programar en pasos pequeños con las pruebas primero
Úsalo cuando una IA programe desde peticiones vagas en un repositorio con especificaciones y planes. Anota las dudas y espera respuesta, actualiza especificación y plan, escribe antes pruebas que fallan, revisa los archivos cambiados, protege la base de datos y deja un traspaso claro.
Crear reglas de un verificador de accesibilidad que devuelvan aprobado, fallo o incompleto
Para cuando una IA añade o cambia reglas en un verificador de accesibilidad web. Separa las capas de DOM y de dependencias, lee los datos HTML y ARIA de un solo sitio, prueba en páginas realistas con Shadow DOM, sincroniza las traducciones y evita cambios incompatibles.
Generar esquemas de comandos para agentes de IA a partir de los comandos y flags reales
Úsalo al crear los esquemas que dicen a los agentes de IA qué comandos existen y cómo llamarlos. Los genera en un solo sentido desde una lista revisada y los comandos reales, y comprueba la cobertura, los ejemplos y la seguridad y confirmación.
Haz cambios pequeños y compatibles en un proyecto Java dividido en módulos
Para que una IA modifique un proyecto Java dividido en módulos. Revisa primero las reglas de compilación y CI, mantiene funcionando las versiones antiguas de Java y las dependencias entre módulos, prueba en el nivel adecuado y pregunta antes de cambios amplios o riesgosos.
Añadir funciones a una biblioteca multilenguaje de infraestructura como código sin romper a los usuarios actuales
Úsalo al cambiar una biblioteca tipada de IaC que genera enlaces para otros lenguajes. Pone cada función en la capa adecuada, evita sintaxis que los enlaces no admiten, protege los cambios con indicadores de funciones, limita los permisos y añade documentación y pruebas.
Añada módulos a un servidor Go sin debilitar la seguridad
Para crear o revisar funciones de un servidor Go ampliable. La IA escribe cada módulo en orden, de la creación a la limpieza, lee la configuración con rigor, pasa pruebas, lint y compilación en Linux, macOS y Windows antes de fusionar, y deja las pull requests a una persona.
Crea una app TypeScript para nativo y web siguiendo las reglas del repositorio
Úsalo al crear o modificar una app TypeScript que funciona en nativo y web. La IA sigue los scripts y la estructura de carpetas del repositorio, reutiliza los componentes compartidos, prepara los textos de pantalla para traducirlos y prueba cada plataforma afectada antes de terminar.
Cambiar un repositorio de pila completa sin romper la compatibilidad
Úsalo cuando una IA edite un repositorio de pila completa. Lee primero sus guías, mantiene compatibles las claves de la base de datos, las migraciones y los campos de la API, reutiliza los componentes compartidos y los archivos de traducción, e informa solo de lo que ejecutó.
Corrige pruebas E2E fallidas observando el navegador real
Úsalo cuando falla una prueba E2E. Define el estado de éxito visible, ejecuta la prueba en un navegador real, reúne capturas y errores de consola, clasifica la causa en prueba, código o entorno, aplica el arreglo mínimo y repite hasta que pase o deba parar.
Crea un servicio de agentes de programación que recibe peticiones del chat y del gestor de incidencias
Para un servicio cuyos agentes de programación reciben trabajo del alojamiento de código, el gestor de incidencias y el chat. Separa los roles principal, revisor y analizador, usa un entorno aislado por hilo, fija el orden del middleware y deja activar la reparación automática de CI.
Cambiar una API en Go y una SPA en React editando primero la especificación OpenAPI
Para repositorios donde un backend en Go y una SPA en React comparten una especificación OpenAPI. Cambia la especificación y regenera el código sin tocar lo generado, sigue reglas para ajustes, errores, sesiones, descargas y actualizaciones, y prueba antes de informar.
Crear o modificar componentes en una biblioteca de componentes de UI con temas
Úsalo cuando una IA añade o cambia un componente en una biblioteca de UI reutilizable. Localiza los archivos afectados, mantiene los valores predeterminados del tema, la accesibilidad y el diseño de derecha a izquierda, y añade pruebas y documentación.
Convertir una idea de software en un sistema multiagente probado
Para crear un sistema donde varios agentes de IA y herramientas trabajan juntos. Hace una pregunta a la vez, pide tu aprobación del diseño de roles y comunicación, construye por orden de dependencias y repite 5 escenarios de usuario hasta que pasen.
Cambia un monorepo TypeScript full stack y prueba sus funciones de LLM por su significado
Para una IA que cambia un monorepo TypeScript con funciones de LLM. Ejecuta las comprobaciones por paquete de CI, prueba el comportamiento, no deja datos personales en registros amplios y evalúa las respuestas del LLM por su significado, no por sus palabras.
Crea una aplicación TypeScript full-stack con esquemas de API compartidos por servidor y cliente
Úsalo al crear o cambiar una aplicación TypeScript full-stack. La IA define una sola vez cada solicitud y respuesta de la API para rutas y hooks del cliente, comprueba la autenticación antes de leer la entrada, mantiene coherentes dependencias, caché y estilos, y escribe pruebas rápidas.
Haz cambios en un monorepo full stack sin romper los paquetes compartidos
Úsalo cuando una IA edita un monorepo con apps y paquetes compartidos. Ubica cada cambio en el módulo correcto, recompila los bundles generados, no mezcla los datos de cada organización y entrega un pull request con resultados de pruebas.
Cambiar el código de una base de datos de alto rendimiento sin perder velocidad ni compatibilidad
Úsala cuando una IA modifique una base de datos centrada en la velocidad que abarca Java, SQL, Rust, código nativo y CI. Da reglas de estilo, NULL, limpieza de memoria, pruebas de queries, fallos, pull requests y build, y cierra con una revisión antes de dar el trabajo por terminado.
Modificar una app de formación en seguridad con fallos intencionados sin romper sus retos
Úsalo al editar una app de formación cuyas vulnerabilidades son lecciones. Distingue retos intencionados de fallos accidentales, hace cambios pequeños, limpia el relleno de la IA, ejecuta las pruebas requeridas y la red de seguridad, y sincroniza los archivos de corrección.
Modifica un motor de bases de datos analíticas en C++ y pasa sus pruebas
Úsalo al cambiar un motor de bases de datos analíticas en C++. La IA sigue el cambio del análisis de SQL a la ejecución, edita los archivos generados desde su fuente, respeta las reglas de C++ y de errores, y pasa las pruebas de lógica SQL y las compilaciones necesarias antes de terminar.
Corregir un defecto reproduciéndolo primero con una prueba que falle
Úsalo cuando se reporta un defecto. La IA decide a qué parte pertenece, reproduce lo que ve el usuario en una prueba que falla, encuentra la causa real, aplica la corrección mínima, conserva la prueba para que no vuelva y repite los pasos del usuario para confirmarlo.
Crear una biblioteca que lea y escriba archivos de imagen por capas sin perder datos
Úsalo al crear una biblioteca para imágenes por capas en formato binario. Separa el análisis binario de la API de usuario, lee las secciones en orden, guarda los datos desconocidos, rehace los grupos de capas, prueba con lectura, escritura y relectura, y automatiza la publicación.
Escribir y revisar documentación de seguridad para desarrolladores
Úsalo al escribir o revisar documentación de seguridad para desarrolladores en un repositorio compartido. Cita solo fuentes que ha leído, indica qué detiene cada medida y qué no, mantiene los cambios pequeños, ejecuta las comprobaciones del repositorio y declara el uso de IA.
Haga cambios pequeños y probados en un gran monorepositorio TypeScript
Úselo si una IA modifica un espacio de trabajo TypeScript con muchos paquetes. Primero conoce la estructura y las herramientas del repositorio, ejecuta solo las compilaciones y pruebas afectadas, no toca los archivos generados sin motivo y comprueba que todo funcione en Unix y Windows.
Modifica un monorrepositorio con varias implementaciones sin que se desajusten
Para cambiar un gran monorrepositorio multilingüe donde un producto tiene varias implementaciones. La IA lee las reglas locales, lleva los cambios visibles a todas, recompila lo que usan las pruebas, prueba lo afectado, añade la entrada de publicación y actualiza la solicitud de cambio.
Haz cambios pequeños en una biblioteca de interfaz con estado sin romper a quienes la usan
Úsalo cuando una IA cambia una biblioteca de interfaz para navegador que guarda estado. Busca al dueño del estado, mantiene compatibles las API públicas y los datos guardados, escribe antes una prueba que falle, elige el tipo de prueba y revisa la diferencia y la nota de publicación.
Crear un emulador local de la nube que funcione con los SDK y CLI oficiales
Úselo al añadir servicios u operaciones a un emulador que imita la nube en su equipo. Confirma el protocolo real, mantiene las solicitudes y respuestas como en la nube real, actualiza juntos el almacenamiento y la configuración, y prueba con los SDK oficiales antes de publicar.
Crea un emulador que reproduzca el bus y la temporización del hardware real
Úsalo al crear o corregir un emulador. Divide el código por piezas del hardware, copia el bus, la temporización y el DMA del hardware real, prueba con programas que pasan en el equipo real y mantiene estables los estados guardados y la API pública.
Hacer cambios pequeños en el código que pasen pruebas locales y revisión
Úsalo cuando una IA modifique tu código. Acuerda qué cambiará y cómo comprobarlo, ejecuta pruebas locales antes y después, revisa los cambios actuales, corrige solo los problemas reales y termina con un informe para que otro agente pueda continuar.
Cambia un monorepositorio de automatización multilenguaje sin romper la compatibilidad
Para cuando una IA cambia un gran monorepositorio de automatización con bindings en varios lenguajes. Mantiene compatibles las API públicas, compila y prueba solo el menor target afectado, comprueba que otro binding actúe igual y pregunta antes de tocar zonas compartidas de alto riesgo.
Mantener sincronizados el backend y el frontend de una app de generación mediante OpenAPI
Para cambiar una app donde se extraen elementos, se confirman en una página de preparación y se genera en un espacio de generación. Regenera los tipos OpenAPI tras cada cambio de API, separa tareas por pantalla y tipos de estado, y mantiene al día la documentación y las notas de versión.
Cambiar y probar código en un monorepo grande con muchos paquetes
Se usa cuando una IA trabaja en un repositorio grande de un framework con muchos paquetes. Revisa la estructura antes de editar, mantiene la compilación al día, elige pruebas según el modo de CI, corrige primero los fallos de CI, no deja secretos en los registros y comprueba cada cambio.
Haz cambios pequeños en una biblioteca de bajo nivel sin romper su API pública
Úsala cuando una IA corrija o cambie una biblioteca de sistema de bajo nivel. Hace cambios pequeños, no toca la API ni la ABI públicas salvo que se pida, compila y prueba el subsistema afectado, falla con seguridad ante errores de memoria y nunca hace push.
Modificar un código base con varios paquetes sin romper lo que ya funciona
Úsalo cuando una IA edita un repositorio con varios paquetes. Averigua qué paquete se encarga del cambio y sus reglas, mantiene el comportamiento y los nombres públicos, añade pruebas y documentación, pide aprobación para nuevas dependencias e informa qué se comprobó y qué riesgos quedan.
Escribe reglas de análisis estático con correcciones automáticas que no cambian cómo se ejecuta el código
Úsalo al crear una regla de análisis estático (lint). Apunta a los patrones comunes, reutiliza los helpers existentes, solo añade corrección automática cuando es segura, prueba la sintaxis delicada y regenera la documentación en vez de editarla a mano.
Desarrolla un framework de flujos de datos en Rust para robótica e IA eligiendo las pruebas según el cambio
Úsalo cuando una IA trabaje en un framework de flujos de datos en Rust para robótica e IA. Mantiene claras las reglas de mensajes, pasa controles antes de cada commit, elige pruebas profundas según el riesgo e informa qué pruebas se ejecutaron.
Al modificar el backend, bloquea ataques desde archivos subidos y datos del usuario
Úsala cuando una IA modifique código del backend que maneja archivos subidos, comprimidos o datos de solicitudes. Sigue los datos externos, los valida antes de usarlos, corrige todas las rutas de código similares y termina con una lista de seguridad, lint y pruebas aprobadas.
Desarrolla una plataforma de automatización multiinquilino sin mezclar inquilinos ni ediciones
Para programar una plataforma de automatización multiinquilino con ediciones comunitaria, empresarial y alojada. Limita cada consulta a su proyecto, usa el cliente seguro para el HTTP saliente contra SSRF, declara cada dependencia donde se usa y prueba todas las ediciones.
Crear y modificar máquinas de estados orientadas a eventos sin romper su comportamiento
Para bibliotecas de máquinas de estados. La IA termina cada evento antes del siguiente, gestiona errores sin saltarse la limpieza, protege hilos y máquinas secundarias, escribe primero pruebas para motores síncronos y asíncronos y alinea código, documentación y esquemas.
Cambiar código en un repositorio grande de varios lenguajes compilando y probando solo lo necesario
Úsalo al cambiar código en un repositorio grande con varios lenguajes. Estudia código parecido, revisa qué herramientas y hardware hay, ejecuta solo las compilaciones y pruebas afectadas, restaura la CI completa antes de fusionar e informa de lo que no se comprobó.
Cambia una CLI de desarrollo web hecha con JavaScript y código nativo en la capa correcta
Úsalo al cambiar una CLI de desarrollo web que mezcla JavaScript y código nativo. Encuentra la capa propietaria del comportamiento, revisa las rutas de comando global y local, y elige las pruebas según el tipo de cambio.
Crea un sistema que lea documentos subidos y permita a agentes de IA buscar en ellos
Para crear un servicio que recibe PDF y otros archivos para búsquedas con IA. Envía cada archivo a un analizador adecuado, conserva títulos y tablas, guarda fragmentos en un formato fijo y busca dentro de un presupuesto, devolviendo evidencias con citas.
Desarrollar software de recuperación sin conexión que divide un secreto en fragmentos
Para software que reparte un secreto entre personas de confianza y lo recupera sin conexión. Rastrea cada cambio, comparte el núcleo criptográfico entre CLI y navegador, mantiene los paquetes sin conexión, prueba primero y escribe textos serenos y claros para personas bajo presión.
Desarrollar un framework que ofrezca una sola API en varios lenguajes de programación
Para crear un framework que genera paquetes para varios lenguajes desde un solo código. Fija reglas para el protocolo JSON entre procesos, los tipos exportables, la generación de código y las pruebas que comprueban que todos los lenguajes se comportan igual.
Crear un agente de IA que investiga con herramientas y probar que no adivina
Para un agente de IA que investiga llamando a herramientas. Las herramientas son de solo lectura por defecto, devuelven datos acotados y explican los fallos con exactitud; los nombres viejos de configuración siguen valiendo, y las pruebas piden datos que solo se hallan consultando.
Preparar contribuciones de código que una persona revisa y envía
Úsalo cuando una IA trabaja en un repositorio de código compartido. Sigue las reglas del proyecto, espera la aprobación del equipo de mantenimiento, no pone secretos en commits ni pruebas y deja en borrador las solicitudes de cambios para que las envíe una persona.
Añade proveedores de IA y almacenes vectoriales a un framework modular de IA en Rust
Úsalo al ampliar un framework de Rust que funciona con muchos proveedores de IA. La IA sigue los traits y builders existentes, mantiene el soporte de WebAssembly, hace que los hooks actúen igual con y sin streaming y comprueba que los cassettes no tengan claves de API.
Añadir una herramienta CLI a un descargador multiplataforma y comprobar cada binario
Úsalo al añadir o revisar una herramienta de línea de comandos en un instalador que descarga binarios publicados. Busca los archivos de cada sistema y arquitectura, define las URL, prueba con una versión fija, inspecciona cada binario y actualiza el catálogo y la PR.
Modificar un kit de UI para consola según su documentación actual y comprobar la pantalla real
Para un kit de UI para consola tras una gran reescritura: la IA sigue la documentación actual del repositorio y no hábitos antiguos, coloca bien las pruebas y graba la terminal en marcha para comprobar los cambios de UI.
Cambiar una gran base de código .NET manteniéndola rápida y compatible
Para editar un gran repositorio .NET de alto rendimiento, como un motor de compilación. Evita asignaciones extra en rutas críticas, trata toda advertencia nueva como cambio incompatible, compila desde el proyecto más pequeño e informa qué compilaciones, pruebas y ejemplos se ejecutaron.
Cambia un espacio de trabajo de Rust con bibliotecas y CLI y compáralo con la herramienta de referencia
Para cambios de una IA en un espacio de trabajo de Rust con bibliotecas y herramientas CLI. Empieza con una prueba que falla, compara los resultados con la herramienta de referencia, evita unwrap() y prueba cada combinación de funcionalidades.
Desarrollar un marco de automatización móvil y corregir fallos en el producto, no en la CI
Para desarrollar con IA un marco de automatización de interfaces móviles. Pone cada cambio en su módulo, elige la capa de pruebas más barata, separa las suites que deben pasar de las que deben fallar y corrige los fallos en el producto, no en la CI.
Crea una herramienta local de grafo de código que los agentes de IA puedan consultar
Úsala al crear una herramienta que convierte una base de código en un grafo local para agentes de IA. Cubre extraer símbolos y enlaces del árbol de sintaxis, instalar y desinstalar en varios clientes, dar respuestas útiles a los agentes, probar en repositorios reales y publicar versiones.
Desarrollar un gestor de cadenas de herramientas multiplataforma y evaluar qué entra en su registro
Úsalo cuando un agente de IA trabaje en un gestor de versiones de herramientas. Sigue las tareas y los módulos del repositorio, pide pruebas de popularidad antes de añadir una herramienta al registro, deja el orden de versiones a cada backend y hace pruebas específicas por plataforma.
Modifica un repositorio de varios módulos con código generado sin pasarte de lo aprobado
Para que una IA trabaje en un repositorio multimódulo con código generado. Lee primero las reglas locales, cambia la especificación y no los archivos generados, hace cambios pequeños y compatibles probados por módulo y deja publicaciones y pipelines a personas autorizadas.
Cambiar y probar un gran repositorio TypeScript que evalúa modelos de IA
Para cuando un agente de IA trabaja en un gran repositorio TypeScript con CLI, web y evaluación de modelos de IA. Lee las reglas locales, prueba los cambios en la CLI o el navegador reales, depura sin borrar cachés ni datos, integra con ramas y CI, y revisa primero la seguridad.
Edita un monorepositorio tipado sin romperlo y mantén al día su wiki
Úsalo cuando una IA trabaja en un monorepositorio tipado grande con una wiki del proyecto. Usa los comandos del repositorio, evita compilaciones obsoletas y fallos en las instantáneas de inicio, ejecuta las pruebas necesarias y actualiza la wiki con sus archivos de origen.
Modifica un proxy inverso en Rust sin romper el bucle de eventos ni la seguridad
Úsalo cuando una IA modifique, pruebe o publique un proxy multiproceso en Rust. Fija reglas para la compilación y los feature flags, errores y registros, el bucle de eventos y el protocolo, pruebas y fuzzing, código sensible para la seguridad, pull requests y publicación.
Cambia un gran monorepo de plataforma y mantén sincronizados todos los clientes afectados
Para cambios de una IA en un monorepo con CLI, bibliotecas cliente y documentación. Lee primero las reglas de cada área, regenera los archivos desde sus fuentes, pregunta antes de cambios incompatibles e informa qué comprobaciones se ejecutaron.
Envía solicitudes de incorporación hechas por IA a un framework de código abierto con revisión humana
Úsalo cuando una IA aporta código a un framework Java de código abierto. Marca el trabajo de la IA, lee el historial antes de corregir, quita las pausas fijas de los tests, sigue el modelo de confianza del proyecto y solo fusiona con aprobación humana.
Añade proveedores y modelos de IA a un catálogo validado por esquemas
Úsala cuando una IA añada o revise un catálogo de proveedores y modelos de IA. Ejecuta el validador del repositorio, hereda los datos comunes en vez de copiarlos, anota solo ajustes de razonamiento y precios verificados y conserva las citas tras sincronizar.
Modifica un gran repositorio de código nativo con compilaciones lentas sin romper las llamadas entre lenguajes
Úsalo al cambiar un gran repositorio con lenguajes nativos, enlaces generados y compilaciones lentas. Ajusta el proceso al tamaño del cambio, empieza por la prueba más pequeña, guarda una vez los logs largos y protege las llamadas entre lenguajes.
Crea un extractor del contenido principal de páginas web y depura el contenido perdido
Úsalo al crear o arreglar un extractor del texto principal de páginas web para navegador, servidor, CLI o edge. La IA respeta el orden de limpieza, registra cada eliminación, bloquea la inyección de scripts y prueba cada arreglo con una prueba que falla primero.
Modifica una biblioteca pública de Go sin romper el código de quienes la usan
Úsalo al cambiar una biblioteca pública de Go. La IA comprueba primero las versiones de Go admitidas y las ramas, ejecuta las pruebas con las herramientas del proyecto, sigue sus patrones de API y prepara un pull request con los resultados y el impacto en la compatibilidad.
Crear una CLI local que busque tus documentos por palabras clave y por significado
Úsala al crear o mantener una herramienta de línea de comandos que busca documentos en tu equipo. Cubre colecciones y notas de contexto, búsqueda por palabras clave y vectorial, límites de resultados, uso como servicio, pruebas y publicación, y deja al usuario los cambios del índice.
Crear habilidades de agente desde la documentación de un proyecto y mantenerlas al día
Úsala al crear habilidades de agente de IA desde la documentación de un proyecto o desde las que publica el origen. Separa las generadas, sincronizadas y escritas a mano, escribe un índice breve y referencias de un solo tema, y actualiza solo lo que cambió desde la revisión registrada.
Crear una biblioteca de datos con API fáciles de encontrar y pruebas con valores reales
Úsalo al crear o cambiar una biblioteca que convierte datos complejos en objetos sencillos. Revisa el código antes de editar, registra el trabajo en incidencias y exige en cada función nueva una prueba con valores reales, un ejemplo documentado ejecutable y errores claros.
Cambiar código en un repositorio de varios paquetes y abrir PR solo desde tu fork
Úsalo cuando una IA edita un repositorio de varios paquetes con upstream de solo lectura. Sigue las instrucciones de cada carpeta, sube solo a tu fork, respeta tus cambios sin confirmar, marca el autor de cada prueba de Python e informa con comprobaciones reales.
Crear memoria a largo plazo para agentes de IA con búsqueda en grafos y vectores
Úsalo para que los agentes de IA guarden conocimiento entre sesiones. Convierte archivos, URL y texto en datos de grafos y vectores consultables, separa los datos de cada usuario con autenticación y permite cambiar de almacenamiento o de modelo sin tocar el código central.
Cambia un servicio de autorización basado en grafos escribiendo primero las pruebas
Úsalo al cambiar un servicio de autorización basado en grafos. Sigue la ruta de cada solicitud, usa los objetivos de build y las reglas de lint del repositorio, escribe primero una prueba que falle y no toca a mano los archivos generados.
Modifica un framework web con seguridad de tipos y separa el código de base de datos en tres capas
Úsalo al cambiar un framework web con seguridad de tipos y varios paquetes. Trabaja dentro del entorno fijado, prueba rápido y luego por completo, mantiene pequeños los módulos públicos, separa en capas el acceso a la base de datos y nunca hace force-push.
Mantén los documentos de habilidades de IA en un solo lugar y escríbelos para que la IA los consulte
Para mantener documentos de habilidades de IA. Conserva un archivo fuente y regenera las copias desde él, pone primero las tablas de decisión y los detalles en referencias, prueba el comportamiento antes y después de cambiar y deja la versión a la publicación automática.
Amplía un compilador SQL multidialecto sin cambiar lo que significan las consultas
Úsalo al cambiar un compilador SQL que convierte SQL en un AST y lo genera para otras bases de datos. Busca primero la capa responsable, mantiene el significado entre dialectos, arma el SQL con funciones auxiliares del AST en vez de cadenas y prueba la ejecución real y la velocidad.
Escribir y publicar habilidades de agente que se activen bien y pasen la validación
Para un repositorio de habilidades de agente: la IA escribe descripciones breves sobre qué hace y cuándo usarla, mantiene corto el archivo principal con referencias aparte, sincroniza versiones y documentación y ejecuta los validadores antes de publicar.
Ejecutar una herramienta CLI compleja desde scripts y comprobar el éxito en su informe JSON
Para cuando un script o agente de programación usa una CLI compleja. Revisa antes las tareas y clases, para si una tarea exige licencia y no está configurada, fija entradas y dispositivo y juzga el éxito por el código de salida y el informe JSON, no por el progreso.
Añadir extensiones de archivo o lenguajes nuevos a un repositorio de detección de lenguajes
Úsalo cuando una IA añada extensiones o lenguajes a un detector de lenguajes. Añade muestras de código real y reglas probadas para extensiones compartidas, usa los scripts del repositorio para lo generado y comprueba el uso y las licencias antes del envío.
Editar un generador de documentos con agentes de IA sin confundir su pila actual y la heredada
Úsalo cuando una IA cambie una app multiagente que genera documentos y conserva una pila antigua. Busca el comando de inicio real, prefiere el código a documentos viejos, no cambia nombres de configuración, sigue los cambios entre Python y Node y hace las pruebas mínimas útiles.
Añade módulos a un servicio de red modular sin romper sus límites
Úsala cuando una IA cambie o amplíe un servicio de red hecho de módulos. Une los módulos solo por interfaces compartidas, usa la compilación y las pruebas del repositorio, devuelve errores seguros para el cliente y no comparte estado entre solicitudes.
Cambiar un monorepo autoalojado de automatización de certificados sin exponer secretos
Úsalo cuando una IA cambie una herramienta autoalojada que pide, renueva y despliega certificados con ACME. Cambia el paquete o plugin correcto, escribe primero las pruebas, añade migraciones SQL, sigue los patrones de UI y no deja certificados ni claves en código ni registros.
Corrige y prueba un generador de envoltorios de bibliotecas nativas para muchos lenguajes
Úsalo al cambiar una herramienta que genera envoltorios de bibliotecas nativas para muchos lenguajes. Busca la etapa donde empieza el fallo, ejecuta pruebas del tamaño justo, añade pruebas de regresión y actualiza el registro de cambios.
Crear un repositorio de habilidades de agentes de IA que revisan la calidad de sitios web
Para añadir o editar habilidades que revisan la velocidad, accesibilidad y SEO de una web. Fija el formato y los nombres de SKILL.md, archivos cortos, ejemplos de antes y después, scripts de shell que paran ante errores y un orden de problemas por impacto en el usuario.
Modificar un repositorio full stack con sus propios comandos y pruebas
Úsalo cuando una IA edite un repositorio con frontend, API, SDK, CLI y base de datos. Usa los comandos y versiones del repositorio, separa el papel de cada capa, prueba en la capa correcta, revisa las páginas cambiadas y las API con inicio de sesión, e informa lo comprobado.
Desarrolla funciones a partir de especificaciones aprobadas antes de programar
Úsalo cuando una IA crea software por etapas desde especificaciones. Separa las pautas del proyecto de cada especificación, escribe requisitos, diseño y tareas en orden con aprobación humana, pide una revisión independiente y confirma el final con evidencias recientes.
Escribe reglas en un repositorio de reglas de frontend y compruébalas antes de publicar
Úsala cuando una IA edita un repositorio de reglas de frontend (accesibilidad, rendimiento, SEO, seguridad). Fija los metadatos de cada regla, el orden de las secciones y umbrales medibles, deja la UI compartida en el sistema de diseño y ejecuta todas las comprobaciones antes de publicar.
Haz que un agente de codificación de IA entregue código sin advertencias e informes honestos en un repositorio de compilación estricta
Úsalo cuando un agente de codificación de IA trabaje en un repositorio con controles de compilación estrictos. Compila y valida antes de cada push, sigue las reglas de commit, escribe código seguro y comprueba cada afirmación con el código.
Corrige la causa raíz en una base de código grande y mantén compatible la API pública
Úsalo cuando una IA modifique una base de código grande y en capas. Mantiene cortos los registros de compilación, rastrea los errores hasta su causa de origen, revisa su propio diff en busca de helpers que solo tapan problemas y escribe un pull request claro.
Mantener una base de código grande y modular fácil de leer y de cambiar sin romperla
Úsalo cuando una IA trabaja en una base de código grande dividida en muchos componentes. Da reglas sobre estilo de código, tamaño de archivos y cambios, revisión de código, pruebas, nombres de la API y builds, para que los cambios sigan pequeños, legibles y no rompan otras partes.
Haz que una IA cambie solo el código necesario y pregunte antes de lo arriesgado
Úsalo cuando un agente de IA edita el código de tu proyecto. Fija primero el alcance, añade solo código útil y pruebas que detecten errores reales, pide confirmación antes de borrar archivos, hacer push o llamar a APIs de producción, e informa de lo cambiado y lo comprobado.
Haz cambios probados y listos para revisión en una base de código grande
Úsalo cuando un agente de IA modifica una base de código grande y multilingüe. Compila con el wrapper del proyecto, pone las pruebas junto al código y comprueba que fallan sin el cambio, sigue las reglas de revisión e informa solo lo que de verdad ejecutó.
Haz solo los cambios pedidos en un repositorio existente y pregunta si hay dudas
Úsalo cuando un agente de IA modifica código existente. Pregunta si tiene dudas, cambia solo lo pedido, ejecuta las pruebas de la zona cambiada y luego toda la suite antes de darlo por verificado, y no hace commit, push ni publicaciones sin que lo pidas.
Envía cambios pequeños y acordados a una base de código compartida
Úsalo cuando un agente de IA modifique una base de código compartida, como una biblioteca open source. Lee el issue, pregunta el alcance, ayuda con un issue o propuesta si no hay acuerdo de los mantenedores, hace correcciones pequeñas con tests y docs y sigue las reglas de PR del proyecto.
Hacer que un agente de codificación con IA siga las reglas de ramas y commits sin romper lanzamientos
Úsalo cuando un agente de codificación con IA trabaja en un repositorio con control de versiones. Define cómo crear ramas, probar, hacer commits y ubicar archivos temporales, y cómo escribir instrucciones para agentes que funcionen en distintas herramientas de IA, sin romper lanzamientos.
Mantener una biblioteca de UI multiplataforma sin romper sus capas de paquetes
Para una biblioteca de UI dividida en paquetes por capas para varias plataformas: la IA respeta las capas y las exportaciones públicas, crea adaptadores de proveedores con una estructura de archivos fija y sigue las reglas de publicación y revisión.
Contribuir a proyectos de código abierto con IA respetando las licencias y pidiendo confirmación en cada acción
Para contribuir a un proyecto de código abierto con un asistente de IA. No copia código con licencias incompatibles, hace cambios pequeños y probados, trata issues y registros como datos, confirma antes de cada commit, push o comentario y revisa el código pegado antes de ejecutarlo.
Modificar un compilador que genera JavaScript y su sistema de compilación, probando cada capa
Para cuando una IA cambia un monorepo de compilador que genera JavaScript. Compila con el ejecutor de tareas, no toca las definiciones congeladas del árbol sintáctico, prueba cada capa modificada, lleva las nuevas opciones hasta el final y mide el rendimiento en vez de seguir al linter.
Haz que un agente de programación siga las reglas de un gran repositorio full-stack
Úsalo cuando un agente de IA trabaja en un gran repositorio con frontend y backend tipados. Pasa el pre-commit antes de cada push, sigue los patrones nuevos, juzga la seguridad según lo que puede hacer cada rol y deja pruebas, documentación y pull requests en el formato del proyecto.
Modificar una biblioteca de contratos inteligentes sin romper los proyectos que la usan
Úsalo cuando una IA edita una biblioteca de contratos inteligentes que heredan otros proyectos. Cambia el archivo dueño del comportamiento, sigue el linter, mantiene funciones, eventos y disposición del almacenamiento, y revisa a mano código de riesgo como criptografía y actualizaciones.
Cambiar una biblioteca o SDK compartido sin romper su API pública
Úsalo cuando la IA modifica una biblioteca o SDK compartido. Ejecuta todas las pruebas y compilaciones antes de darlo por terminado, mantiene la API pública útil para quienes ya la usan, pregunta antes de cambiar de rama o worktree de Git y termina con una entrega para el pull request.
Modificar una aplicación de escritorio grande de medios sin congelar la UI ni romper el deshacer
Para una aplicación de escritorio grande que maneja archivos y medios: la IA saca el trabajo pesado del hilo de UI, cubre cancelaciones y casos límite, mantiene exacto el deshacer e informa solo de las pruebas que realmente ejecutó.
Mantener una biblioteca CSS-in-JS que funcione en navegador, servidor y nativo
Úsalo cuando una IA de programación trabaja en una biblioteca CSS-in-JS orientada a estándares. Limita los estilos a CSS estándar, evita fallos en cada entorno, escribe antes las pruebas según la especificación y fija cómo hacer notas de versión, documentación y demos con código real.
Haz que la IA escriba servicios FastAPI y detecte errores comunes al revisar
Úsalo cuando una IA crea o revisa un servicio FastAPI. Fija las versiones mínimas, cuándo usar rutas async o sync, cómo escribir modelos Pydantic y dependencias, cómo trabajar con la base de datos y las pruebas, y da una tabla de errores comunes en un diff con su corrección.
Trabajar en un monorepo frontend de TypeScript sin saltarse los límites entre paquetes
Para cuando una IA cambia un frontend modular en TypeScript. Cubre los límites entre paquetes y un núcleo sin framework, cambiar el estado solo por su acción dueña, dónde van archivos y pruebas, los checks antes del commit, el orden de release y las capas de UI.
Haz que la IA lea antes de editar un repositorio grande y publique solo con revisión
Úsalo cuando la IA trabaja en un repositorio grande con muchos paquetes. Lee el código, las dependencias y las pruebas antes de juzgar un arreglo, usa una sola forma para cada cosa, nunca ejecuta código no confiable en local y cambia el código compartido solo con revisión y tu aprobación.
Dar reglas de trabajo compartidas a los agentes de IA que investigan y mejoran un repositorio
Úsalo cuando agentes de IA investigan y mejoran un repositorio por su cuenta. Define qué guardar en la memoria compartida, cuándo planificar antes de actuar, cómo manejar los push y los secretos expuestos, y cómo probar los cambios y la automatización antes de darlos por terminados.
Modificar un pipeline de datos con plugins que corre en dos runtimes sin romperlo
Úsalo cuando un agente de código trabaja en un backend con plugins sobre dos runtimes. Guarda las versiones en un archivo, aplica los filtros de test a la tarea correcta, sigue las reglas de plugins, concurrencia y capas de servicio, y comprueba que cada test nuevo falle sin su cambio.
Modificar un depurador de bajo nivel escribiendo primero las pruebas, sin romper otras plataformas
Úsalo cuando una IA modifica un depurador de un lenguaje compilado que funciona en varios sistemas y backends. La IA escribe antes una prueba que falla, aísla el código de cada sistema, revisa todos los backends al cambiar interfaces compartidas y empieza los commits con el subsistema.
Hacer que la IA escriba código de sistemas con cuidado, hasta los tipos y el manejo de errores
Para cuando una IA ayuda en un código de sistemas exigente. Revisa su código al menos el triple de lo que tardó en escribirlo, cubre todos los errores, lleva las reglas a los tipos, mantiene compatibles los formatos viejos y nuevos y hace commits pequeños que compilan.
Crea skills y plugins de agente que se cargan y se activan correctamente
Úsalo al crear un skill o plugin para un agente de IA y enviarlo a revisión. Cubre una sola fuente de metadatos, la estructura de directorios, nombres y descripciones que se activan bien, hooks rápidos y la lista de verificación previa.
Comprobar que un cambio hace falta antes de abrir un pull request en un proyecto compartido
Para cuando un agente de IA quiere enviar un pull request a un proyecto que mantienen otros. Comprueba que el problema ocurrió de verdad, que el cambio va en el proyecto central y que una persona aprobó el diff completo antes de enviarlo.
Mantener a un agente de código de IA dentro de lo pedido en un repositorio de aplicación por capas
Úsalo cuando una IA programa en un repositorio con frontend, backend y empaquetado de escritorio. Clasifica cada solicitud (consulta, cambio, compilación, publicación), elige las pruebas según la parte cambiada y pide permiso antes de commits, pushes, publicaciones o datos reales.
Modificar una base de código funcional con tipado estricto sin ocultar errores
Úsalo cuando un agente de IA trabaja en código funcional con tipado estricto. Fija reglas de estilo, errores, servicios y capas, esquemas, registros y componentes de UI, y exige pasar la comprobación de tipos, las pruebas y la compilación antes de dar algo por terminado.
Crea una herramienta de línea de comandos que no pierda datos ni ejecute código sin aprobar
Úsala cuando una IA cree o cambie una CLI que ya tiene usuarios. Mantiene compatibles opciones y configuración, se detiene antes de destruir trabajo, ejecuta los hooks del proyecto solo tras aprobarlos, rastrea cada subproceso y muestra lo local antes que la red.
Modifica una gran base de código de runtime multilenguaje sin romper el comportamiento existente
Para un gran proyecto de runtime nativo y de scripts con dependencias incorporadas y parcheadas. La IA lee primero la guía más cercana, usa los atajos de compilación y prueba, sigue sus tipos propios y prohibiciones, y pone los cambios tras indicadores de compatibilidad.
Desarrolla una extensión de índice para bases de datos que pase las pruebas y resista caídas
Úsalo cuando una IA cree o cambie una extensión de índice de base de datos. Trata cada fallo de prueba como real, sigue un orden fijo antes del commit y registra cada cambio de página para que la recuperación y los servidores en espera funcionen.
Mantener un SDK de protocolo bidireccional en un monorepo de TypeScript sin romper su API pública
Úsalo al cambiar un SDK tipado, publicado en varios paquetes, donde cliente y servidor envían peticiones. Elige con intención lo que se exporta, añade operaciones en ambos lados con comprobación de capacidades, registra los cambios incompatibles y ejecuta los ejemplos como pruebas.
Ejecutar en un sandbox un pipeline de IA que encuentra y corrige fallos de seguridad
Úsalo al operar un pipeline autónomo que ejecuta código no confiable para encontrar fallos reales. Aísla cada ejecución en contenedores, informa de los hallazgos según llegan y deja cada parche para que lo revise una persona.
Añadir código de backend y las pruebas adecuadas a una aplicación con varios servicios
Para un agente de IA que cambia una aplicación con varios servicios y trabajadores en segundo plano. Revisa el entorno y los servicios, pone el código de base de datos y de tareas en su sitio, define trabajos y errores según el proyecto, elige un tipo de prueba y planea antes de programar.
Añadir plugins de proveedores y generadores a un repositorio multimódulo
Úsalo cuando una IA trabaja en un repositorio multimódulo ampliado con proveedores y generadores de secretos. Ejecuta todo con el ejecutor de tareas, añade extensiones de la forma prevista y se detiene antes de cualquier push o publicación.
Modificar una app de escritorio de diseño con IA local-first sin romper sus reglas de producto
Para cuando un agente de IA programa en una app de escritorio que diseña con IA en espacios de trabajo locales. Indica qué archivo de instrucciones manda, las reglas fijas, cómo se organizan sesiones, almacenamiento y herramientas, los cuatro niveles de permisos y qué evitar.
Haz que la IA siga el estilo y las reglas de módulos de un gran backend Java
Úsalo si una IA trabaja en un gran servidor Java de módulos y proveedores. Lee primero los puntos de entrada, sigue el estilo que se comprueba al compilar y la versión mínima de Java, declara cada módulo que usa, comprueba en el código antes de afirmar y prueba en local antes de subir.
Crea una app que reúne eventos de actividad de muchas fuentes y los muestra en varias superficies
Para una app que reúne eventos de muchas herramientas y los muestra en una extensión de editor y en un servidor aparte. Mantiene las capas en una sola dirección, convierte cada fuente en un tipo de evento, deja añadir fuentes sin tocar lo demás y guarda el estado con seguridad.