Curso de Antigravity para empresas — Adopción de agentes IA

Instalación de Antigravity en Windows, macOS o Linux siguiendo las políticas internas de software aprobado y control de versiones de la empresa.

Configuración inicial del editor, tema, extensiones, keybindings, workspace, terminal, navegador y preferencias de uso del agente.

Revisión de opciones de importación desde entornos previos cuando el desarrollador viene de VS Code, Cursor u otro editor compatible.

Inicio de sesión con una cuenta autorizada por la organización, evitando cuentas personales no permitidas en repositorios corporativos.

Configuración de workspaces separados para proyectos de laboratorio, proyectos activos, repositorios críticos y pruebas controladas.

Validación de que Antigravity puede compilar, ejecutar tests y abrir soluciones .NET sin rutas rotas ni extensiones ausentes.

Comprobación de configuración del navegador gestionado para prácticas de validación UI y browser-in-the-loop.

Configuración inicial de permisos de terminal y revisión para evitar que el agente ejecute comandos sensibles sin autorización.

Preparación de un repositorio de laboratorio con una API .NET, pruebas, frontend básico, documentación y errores controlados.

Creación de una checklist de onboarding para que cualquier desarrollador pueda empezar sin improvisar ajustes peligrosos.

Uso de workspaces para separar contextos de trabajo, soluciones .NET, ramas, tareas, conversaciones y agentes en ejecución.

Organización de soluciones con varios proyectos: API, dominio, aplicación, infraestructura, tests, frontend, workers y herramientas.

Apertura de carpetas y repositorios con criterios de seguridad, evitando mezclar proyectos confidenciales con laboratorios o pruebas.

Gestión de ramas de Git desde Antigravity para aislar experimentos, refactorizaciones, cambios generados por agente y correcciones de bugs.

Preparación de workspaces para monorepos .NET, microservicios, aplicaciones Blazor, librerías internas y soluciones legacy.

Control de contexto enviado al agente para que analice lo necesario sin mezclar módulos no relacionados o información sensible.

Uso de conversaciones separadas por tarea para evitar que el agente arrastre decisiones antiguas o contexto irrelevante.

Documentación del workspace con README, comandos de build, comandos de test, estructura de proyectos y dependencias.

Revisión de problemas frecuentes: rutas absolutas, SDK incorrecto, proyectos no restaurados, dependencias ausentes y permisos de carpeta.

Creación de una estrategia de workspace por tipo de trabajo: bugfix, feature, refactorización, prueba, documentación y análisis de arquitectura.

Uso del Agent Manager como superficie principal para lanzar, observar, revisar y coordinar agentes sobre distintos espacios de trabajo.

Creación de tareas claras para agentes: objetivo, contexto, restricciones, alcance, pruebas esperadas y definición de terminado.

Supervisión de varios agentes trabajando en paralelo sobre bugs, tests, documentación, análisis de deuda o tareas de mantenimiento.

Diferenciación entre tareas adecuadas para trabajo asíncrono y tareas que requieren intervención continua del desarrollador.

Revisión del progreso del agente mediante task lists, planes, walkthroughs, artifacts, diffs y resultados de ejecución.

Comentario sobre artifacts y resultados para redirigir al agente sin reiniciar todo el trabajo desde cero.

Control de tareas largas para evitar que el agente haga cambios amplios sin checkpoints intermedios.

Gestión de prioridades cuando varios agentes trabajan sobre ramas o áreas relacionadas del mismo repositorio.

Cierre de tareas con validación explícita: compila, pasan tests, se revisó diff, se documentó y no hay cambios fuera de alcance.

Diseño de un flujo de Agent Manager para mantenimiento semanal de una solución .NET con bugs, tests y documentación.

Uso de Editor View para revisar archivos, modificar código manualmente, pedir cambios inline y comparar propuestas del agente.

Aplicación de comandos naturales sobre clases C#, controladores, handlers, entidades, componentes Razor, tests y configuración.

Revisión de diffs dentro del editor para entender exactamente qué cambió, por qué cambió y qué impacto tiene.

Envío de problemas del editor al agente para que explique errores de compilación, warnings, analyzers o fallos de IntelliSense.

Uso de terminal integrado para restaurar paquetes, compilar, ejecutar tests, levantar APIs y revisar logs.

Intervención manual cuando el agente se acerca a una solución correcta pero necesita criterio de diseño o ajuste fino.

Comparación entre aceptar cambios completos, editar parcialmente, rechazar propuestas o pedir una segunda iteración.

Uso de comentarios inline para guiar al agente en refactorizaciones pequeñas sin perder contexto.

Prevención de cambios masivos en archivos Razor, Program.cs, pipelines o configuración sin revisión humana línea por línea.

Creación de un flujo híbrido donde el agente investiga y propone mientras el desarrollador toma las decisiones clave en el editor.

Selección del modelo adecuado según tipo de tarea: generación rápida, análisis profundo, refactorización, depuración, documentación o revisión.

Comprensión del impacto de los modelos en coste, latencia, calidad de razonamiento, capacidad de seguir instrucciones y precisión en código .NET.

Uso de modos de planificación cuando la tarea afecta a varios proyectos, arquitectura, migraciones, tests o decisiones técnicas sensibles.

Aplicación de modos más rápidos para cambios acotados, explicación de errores, generación de snippets o documentación puntual.

Diseño de criterios para no usar siempre el modelo más potente cuando la tarea no lo justifica.

Comparación de respuestas entre modelos cuando existen dudas de diseño, seguridad, rendimiento o compatibilidad.

Control de cuotas, límites, disponibilidad y políticas internas sin asumir que todos los usuarios tendrán el mismo acceso.

Documentación de recomendaciones por tarea: bugfix, test, endpoint, Blazor, EF Core, CI/CD, seguridad, performance y legacy.

Revisión crítica de respuestas del modelo cuando propone paquetes, APIs, versiones, comandos o patrones que pueden estar desactualizados.

Creación de una matriz de selección de modelo y modo para equipos .NET con foco en calidad, coste y riesgo.

Configuración de políticas de ejecución de terminal para controlar si el agente puede ejecutar comandos automáticamente o necesita aprobación.

Definición de comandos permitidos, comandos restringidos y comandos prohibidos para proyectos .NET, Git, Docker, bases de datos y scripts.

Uso de políticas de revisión de artifacts para obligar a validar task lists, planes, walkthroughs, screenshots o browser recordings antes de aceptar cambios.

Configuración de políticas del navegador cuando el agente necesita abrir páginas, ejecutar JavaScript, validar UI o interactuar con aplicaciones locales.

Evaluación de riesgos de permitir ejecución automática de comandos como `dotnet test`, `dotnet ef`, `git`, `docker`, `rm`, scripts o migraciones.

Preparación de deny lists y procesos de aprobación para operaciones destructivas o con impacto fuera del workspace.

Aplicación de modos estrictos cuando se trabaja con repositorios sensibles, datos de cliente, infraestructura o proyectos productivos.

Separación de políticas entre laboratorio, proyecto activo, repositorio crítico y pruebas exploratorias.

Registro de decisiones de revisión para saber qué aprobó el desarrollador, qué ejecutó el agente y qué evidencia se generó.

Creación de una política corporativa de autonomía segura para Antigravity en equipos .NET.

Creación de reglas globales para que Antigravity respete el estilo general del equipo: idioma, formato, testing, seguridad y documentación.

Creación de reglas locales por proyecto para arquitectura, naming, estructura de carpetas, patrones .NET, comandos de build y criterios de PR.

Redacción de reglas claras y accionables, evitando frases blandas como “hacer código limpio” sin criterios verificables.

Inclusión de restricciones técnicas: no introducir paquetes sin aprobación, no modificar migraciones aplicadas y no tocar secretos.

Definición de reglas para soluciones ASP.NET Core: Program.cs, DI, middlewares, endpoints, validación, errores y logging.

Definición de reglas para Blazor: componentes pequeños, servicios inyectados, CSS isolation, validación y JavaScript interop controlado.

Definición de reglas para EF Core: migraciones revisables, consultas eficientes, no usar lazy loading sin criterio y no exponer entidades como DTOs.

Uso de reglas para exigir pruebas cuando se cambia dominio, aplicación, API, autorización, contratos o persistencia.

Revisión periódica de reglas obsoletas cuando cambian .NET, frameworks, arquitectura o políticas internas.

Construcción de un catálogo de reglas corporativas para proyectos .NET con ejemplos aceptados y rechazados.

Comprensión de las skills como capacidades reutilizables que empaquetan instrucciones, conocimiento, convenciones y procedimientos para el agente.

Creación de una skill para analizar una solución .NET y devolver mapa de proyectos, dependencias, comandos y riesgos técnicos.

Diseño de una skill para generar endpoints ASP.NET Core con validación, `ProblemDetails`, logging, tests y documentación OpenAPI.

Creación de una skill para Blazor que produzca componentes Razor con parámetros claros, validación, estados de carga y accesibilidad.

Preparación de una skill de testing que cree pruebas xUnit, NUnit, MSTest, TUnit o Selenium según la capa afectada.

Diseño de una skill de EF Core para revisar consultas, mappings, migraciones, transacciones, índices y riesgos de rendimiento.

Creación de una skill de refactorización segura que obliga a generar plan, pruebas de caracterización, cambios pequeños y rollback.

Uso de skills para documentación: ADRs, README, runbooks, walkthroughs, diagrams y resúmenes de pull request.

Versionado de skills como activos de equipo con owner, cambios, ejemplos, revisión y retirada cuando quedan obsoletas.

Construcción de una biblioteca inicial de skills .NET para acelerar tareas frecuentes sin perder consistencia.

Uso de hooks para ejecutar validaciones automáticas antes o después de cambios, comandos o fases del trabajo del agente.

Creación de hooks que ejecutan `dotnet format`, build, tests unitarios, tests de integración o análisis estático tras modificaciones relevantes.

Bloqueo de cambios peligrosos en `.env`, secretos, certificados, archivos de producción, scripts destructivos o pipelines sensibles.

Diseño de hooks específicos para proyectos .NET: restauración, compilación, pruebas, validación de OpenAPI y comprobación de migraciones.

Uso de hooks para exigir evidencia antes de que el agente marque una tarea como completada.

Registro de comandos ejecutados, resultados, errores, archivos modificados y validaciones lanzadas.

Evitación de hooks demasiado lentos que hacen inviable el flujo de trabajo diario.

Separación entre hooks informativos, hooks de bloqueo y hooks de auditoría.

Revisión de hooks con DevOps y AppSec para evitar automatizaciones peligrosas, frágiles o difíciles de mantener.

Creación de un conjunto de hooks base para repositorios .NET con build, test, seguridad y protección de archivos sensibles.

Comprensión de MCP como mecanismo para conectar Antigravity con herramientas, datos y sistemas externos de forma controlada.

Identificación de fuentes útiles para desarrollo .NET: GitHub, GitLab, Azure DevOps, Jira, Confluence, bases de datos, logs y documentación interna.

Diseño de MCPs de solo lectura para empezar, reduciendo riesgo antes de permitir acciones de escritura o cambios automáticos.

Configuración de permisos mínimos, tokens, rotación, entornos, timeouts, logs y propietarios de cada servidor MCP.

Prevención de prompt injection cuando el agente lee issues, comentarios, documentación, logs, páginas web o datos no confiables.

Uso de MCP para consultar documentación interna de arquitectura, estándares .NET, contratos API o runbooks sin copiarlos manualmente.

Conexión con herramientas de observabilidad para ayudar a analizar errores, trazas, métricas o incidentes de servicios ASP.NET Core.

Separación de MCPs por entorno: laboratorio, desarrollo, staging y producción, con controles más estrictos en entornos sensibles.

Documentación de cada MCP con propósito, datos accesibles, acciones permitidas, owner, riesgos y procedimiento de baja.

Creación de una estrategia MCP para equipos .NET que equilibre contexto rico, seguridad y trazabilidad.

Uso de plugins para agrupar reglas, skills, hooks y MCPs en paquetes reutilizables por equipo, proyecto o tipo de aplicación.

Diseño de un plugin corporativo para ASP.NET Core con reglas de arquitectura, skills de endpoints, hooks de build y MCP de documentación.

Diseño de un plugin para Blazor con estándares de componentes, validación, accesibilidad, CSS isolation y revisión visual.

Creación de un plugin AppSec que active reglas de secretos, autorización, sanitización, dependencias y revisión de cambios sensibles.

Gestión de versiones de plugins para evitar que cambios en reglas o hooks rompan flujos de varios equipos sin aviso.

Documentación de plugins con objetivo, contenido, comandos, permisos, ejemplos y procedimiento de actualización.

Separación entre plugins obligatorios para repositorios corporativos y plugins opcionales por preferencia de equipo.

Prueba de plugins en repositorios de laboratorio antes de extenderlos a proyectos activos.

Revisión de conflictos entre plugins cuando varios definen reglas, hooks o MCPs sobre la misma tarea.

Construcción de un plugin .NET de referencia para estandarizar uso de Antigravity en la organización.

Uso de Knowledge Items para conservar aprendizajes, patrones, decisiones y soluciones recurrentes que el agente puede reutilizar.

Definición de qué conocimiento debe persistirse: comandos de build, decisiones de arquitectura, convenciones, errores frecuentes y soluciones validadas.

Evitación de guardar datos sensibles, secretos, información personal, credenciales o detalles de clientes dentro de memoria persistente.

Creación de conocimiento útil para proyectos .NET: estructura de solución, puertos locales, comandos de test, rutas críticas y patrones aceptados.

Revisión periódica del conocimiento acumulado para eliminar entradas obsoletas, incorrectas o contradictorias.

Uso de Knowledge Items para mejorar onboarding de agentes y reducir repeticiones de contexto en tareas frecuentes.

Diferenciación entre documentación formal del repositorio y memoria operativa del agente.

Gestión de conocimiento por proyecto para evitar que un patrón válido en una solución se aplique indebidamente a otra.

Auditoría de entradas persistidas cuando hay cambios de arquitectura, versión de .NET, framework o política interna.

Creación de una política de memoria técnica segura para Antigravity en proyectos .NET.

Uso de la CLI para interactuar con Antigravity desde terminal, abrir proyectos, lanzar tareas y trabajar fuera de la interfaz principal.

Ejecución de comandos controlados para analizar soluciones, revisar errores, generar documentación o consultar estado de agentes.

Integración de la CLI con scripts de desarrollo local sin convertirla en un punto ciego de seguridad.

Uso de comandos de ayuda, gestión de conversaciones, configuración y tareas recurrentes desde flujos de terminal.

Control de permisos cuando la CLI puede interactuar con archivos, herramientas locales, repositorios y comandos del sistema.

Preparación de scripts seguros para tareas repetibles como diagnóstico de build, resumen de cambios, análisis de tests o revisión de deuda.

Evitación de automatizaciones que aceptan cambios del agente sin revisión de diff, tests y criterios humanos.

Registro de salidas de CLI como artifacts o documentación de soporte para pull requests.

Comparación entre uso desde Agent Manager, Editor View y CLI según contexto, velocidad y control.

Creación de un flujo CLI para revisar una rama .NET antes de abrir pull request.

Redacción de instrucciones completas con objetivo, contexto, alcance, restricciones, criterios de aceptación y comandos de validación.

Separación entre tareas de investigación, planificación, implementación, testing, documentación y revisión para evitar cambios improvisados.

Uso de prompts orientados a evidencia: citar archivos, explicar riesgos, listar cambios, ejecutar tests y devolver walkthrough.

Petición de cambios pequeños y revisables, especialmente en arquitectura, seguridad, persistencia o pipelines.

Definición de restricciones explícitas: no tocar archivos fuera de alcance, no añadir paquetes, no modificar migraciones aplicadas y no usar datos reales.

Diseño de prompts para análisis de bugs: reproducir, aislar causa, proponer fix, añadir test de regresión y validar resultado.

Diseño de prompts para nuevas features: plan, contrato, endpoint, dominio, persistencia, UI, tests y documentación.

Evitación de prompts vagos como “mejora esta app” que abren la puerta a cambios grandes y difíciles de revisar.

Creación de plantillas de prompts para tareas .NET recurrentes: API, Blazor, EF Core, tests, CI/CD, documentación y refactorización.

Construcción de una biblioteca de prompts corporativos alineada con reglas, skills y políticas de Antigravity.

Uso de Antigravity para mapear proyectos, referencias, capas, módulos, carpetas, puntos de entrada y dependencias internas.

Identificación de zonas críticas por complejidad, frecuencia de cambio, falta de tests, errores recurrentes o ownership difuso.

Petición de resúmenes por módulo que incluyan propósito, clases principales, dependencias, riesgos y preguntas abiertas.

Localización de lógica de negocio dispersa en controladores, servicios, repositorios, vistas, stored procedures o scripts.

Detección de acoplamientos entre UI, dominio, infraestructura, persistencia, configuración y servicios externos.

Generación de diagramas, walkthroughs y mapas de dependencia como artifacts revisables por el equipo.

Uso del agente para entender código legacy antes de modificarlo, evitando refactorizaciones sin pruebas ni contexto.

Identificación de seams para introducir pruebas, extraer servicios, aislar dependencias o crear anti-corruption layers.

Conversión del análisis en backlog técnico con impacto, riesgo, esfuerzo y prioridad.

Creación de un informe de diagnóstico de una solución .NET legacy con evidencias, riesgos y plan incremental.

Uso de Antigravity para crear endpoints ASP.NET Core con contratos claros, validación, errores coherentes y documentación OpenAPI.

Generación de Minimal APIs o controllers según estilo del proyecto, evitando mezclar patrones sin criterio.

Creación de DTOs, validators, handlers, servicios y tests asociados sin exponer entidades de dominio directamente.

Revisión de respuestas HTTP, códigos de estado, `ProblemDetails`, paginación, filtros, permisos y versionado.

Incorporación de logging, métricas, correlation IDs y manejo global de excepciones cuando el endpoint lo requiere.

Uso del agente para detectar inconsistencias entre contrato OpenAPI, implementación, tests y documentación.

Validación mediante `dotnet test`, pruebas de integración, peticiones HTTP y análisis de errores del terminal.

Preparación de artifacts con resumen del endpoint, archivos modificados, contrato, pruebas y escenarios de validación.

Revisión humana de cambios en Program.cs, middleware, DI, seguridad y configuración.

Construcción de una feature API completa con Antigravity desde issue inicial hasta pull request revisable.

Uso de Antigravity para crear componentes Razor con parámetros, eventos, estado, validación y separación de responsabilidades.

Aplicación de agentes a Blazor Web App, Blazor Server, Blazor WebAssembly y Razor Class Libraries según arquitectura del proyecto.

Creación de formularios con `EditForm`, validadores, mensajes de error, estados de carga y experiencia accesible.

Generación de componentes de tabla, filtros, modales, cards, dashboards y navegación con criterios de reutilización.

Control de JavaScript interop para evitar fugas de memoria, inicializaciones duplicadas o conflictos con renderizado Blazor.

Revisión de CSS isolation, estilos globales, Bootstrap, assets estáticos y responsive design.

Uso del browser agent para validar UI, capturar screenshots, generar walkthroughs y comprobar flujos de usuario.

Detección de errores de renderizado, componentes demasiado grandes, estado duplicado y servicios mal inyectados.

Creación de pruebas bUnit, Selenium o Playwright cuando el cambio visual necesita cobertura automatizada.

Desarrollo de una pantalla Blazor completa con agente, revisión de diffs, validación visual y pruebas.

Uso de Antigravity para revisar DbContext, entidades, mappings, queries, migraciones y problemas de rendimiento en EF Core.

Generación de consultas más eficientes, evitando N+1, carga excesiva, tracking innecesario o filtros en memoria.

Revisión de migraciones antes de aplicarlas para detectar pérdida de datos, cambios destructivos, índices ausentes y defaults peligrosos.

Creación de repositorios, adaptadores o query handlers según arquitectura del proyecto, evitando patrones genéricos sin valor.

Diseño de pruebas de integración con base de datos de test, Testcontainers, SQLite o entorno controlado.

Uso del agente para explicar errores de EF Core, conflictos de migración, problemas de tracking o traducción LINQ.

Protección de connection strings, credenciales y datos reales cuando se usan prompts o artifacts.

Validación de cambios de persistencia mediante tests, scripts, revisión de SQL generado y análisis de impacto.

Documentación de decisiones de datos mediante ADRs, comentarios de migración y walkthroughs.

Refactorización de una consulta o flujo de persistencia con Antigravity, tests y revisión de rendimiento.

Generación de pruebas unitarias para dominio, servicios, handlers, validadores, políticas, mappers y utilidades C#.

Uso de Antigravity para detectar huecos de cobertura, asserts débiles, tests duplicados y escenarios no contemplados.

Creación de builders, fakes, mocks y datos parametrizados para evitar setup repetitivo o poco legible.

Revisión de tests generados para asegurar que validan comportamiento real y no simplemente replican la implementación.

Incorporación de casos negativos, límites, errores de negocio, valores nulos y combinaciones relevantes.

Uso de xUnit, NUnit, MSTest o TUnit según estándar del proyecto, sin mezclar frameworks sin motivo.

Ejecución de tests desde terminal con revisión de fallos, logs y propuestas de corrección por parte del agente.

Generación de tests de regresión a partir de bugs reproducidos.

Refactorización de suites frágiles, lentas o difíciles de mantener con ayuda del agente.

Creación de una batería de pruebas unitarias revisables para un módulo de dominio .NET.

Uso de Antigravity para crear pruebas de integración con `WebApplicationFactory`, TestServer, `HttpClient` y configuración aislada.

Generación de escenarios que validan pipeline ASP.NET Core, routing, middleware, filtros, serialización, errores y autorización.

Preparación de datos de prueba mediante builders, seeds, bases temporales, contenedores o servicios fake.

Sustitución de dependencias externas en el entorno de test sin alterar configuración productiva.

Validación de respuestas HTTP, `ProblemDetails`, payloads, headers, códigos de estado y cambios persistidos.

Revisión de flakiness por datos compartidos, estado global, paralelización, hora del sistema o dependencias no controladas.

Uso del agente para interpretar fallos de test y proponer cambios mínimos en setup, assertions o código productivo.

Creación de artifacts con resumen de pruebas añadidas, escenarios cubiertos y comandos ejecutados.

Integración de pruebas de API en CI/CD con filtros, categorías, reporting y evidencias.

Construcción de una suite de integración .NET con Antigravity desde cero hasta ejecución en pipeline.

Uso de Antigravity para generar pruebas Selenium o Playwright sobre aplicaciones ASP.NET Core, Blazor, Razor Pages o SPA con backend .NET.

Diseño de Page Objects, Component Objects, localizadores estables, esperas explícitas y datos aislados.

Creación de pruebas de login, formularios, tablas, modales, permisos, navegación, exportación y flujos críticos.

Uso del navegador gestionado para reproducir manualmente errores, capturar screenshots y generar browser recordings.

Revisión de flakiness causada por asincronía, renderizado Blazor, overlays, animaciones o datos compartidos.

Preparación de pruebas headless, cross-browser, Docker, Selenium Grid o ejecución en CI/CD.

Separación entre validaciones UI que sí necesitan navegador y validaciones que deben moverse a API o integración.

Generación de evidencias útiles para QA, desarrollo y producto tras cada fallo automatizado.

Uso de prompts para pedir al agente que estabilice una prueba sin introducir sleeps arbitrarios.

Construcción de una prueba UI completa con Antigravity, Selenium o Playwright, artifacts y reporting.

Uso de Antigravity para analizar errores de compilación, excepciones runtime, fallos de test, logs, stack traces y salidas de terminal.

Envío de terminal output al agente para que explique causa probable, archivos implicados y plan de corrección.

Análisis de errores ASP.NET Core: DI fallida, middleware mal ordenado, rutas incorrectas, serialización, autorización y configuración.

Depuración de errores EF Core: migraciones, tracking, concurrencia, relaciones, consultas no traducibles y connection strings.

Diagnóstico de errores Blazor: renderizado, null references, servicios no disponibles, JS interop y problemas de estado.

Generación de hipótesis y validación mediante cambios pequeños, tests de regresión y ejecución controlada.

Evitación de fixes especulativos que cambian varias cosas sin reproducir el problema.

Creación de artifacts de bugfix con causa raíz, prueba que falla, cambio aplicado y prueba que pasa.

Documentación del aprendizaje como Knowledge Item cuando el problema es recurrente en el proyecto.

Resolución guiada de un bug .NET completo desde reproducción hasta PR.

Uso de Antigravity para detectar deuda: clases grandes, métodos largos, duplicación, acoplamiento, dependencias circulares y falta de tests.

Generación de planes de refactorización por fases con alcance, riesgos, pruebas necesarias y criterios de rollback.

Creación de pruebas de caracterización antes de tocar código legacy o reglas de negocio sensibles.

Refactorización de servicios anémicos, controladores grandes, repositorios genéricos, lógica duplicada y componentes Razor sobredimensionados.

Separación gradual de dominio, aplicación, infraestructura y presentación sin reescribir toda la solución.

Revisión de diffs para asegurar que la refactorización no cambia comportamiento observable.

Uso de hooks y tests para validar cada paso antes de continuar.

Documentación de decisiones y deuda aceptada mediante ADRs y backlog técnico.

Evitación de refactorizaciones estéticas que consumen tiempo sin reducir riesgo ni mejorar mantenibilidad.

Ejecución de una refactorización realista con agente, pruebas, walkthrough y revisión humana.

Uso de Antigravity para analizar boundaries, agregados, entidades, value objects, casos de uso, puertos y adaptadores.

Generación de propuestas de estructura hexagonal respetando dependencias entre dominio, aplicación, infraestructura y API.

Revisión de comandos, queries, handlers, eventos de dominio, eventos de integración, Outbox, Inbox y proyecciones.

Detección de lógica de negocio filtrada en controllers, DbContext, servicios externos o componentes UI.

Creación de ADRs para decisiones de arquitectura, alternativas, trade-offs y consecuencias.

Validación de que CQRS o EDA aportan valor antes de aplicarlos por moda.

Uso del agente para revisar acoplamiento entre microservicios, contratos, eventos y bases de datos.

Generación de diagramas y artifacts para explicar flujos distribuidos y límites de contexto.

Creación de pruebas de dominio, integración y contrato asociadas a cambios arquitectónicos.

Diseño de un módulo .NET con DDD y arquitectura hexagonal usando Antigravity como asistente supervisado.

Uso de Antigravity para analizar topologías de microservicios .NET, dependencias, APIs, eventos, bases de datos y workers.

Generación de servicios ASP.NET Core con health checks, OpenAPI, observabilidad, configuración, tests y Dockerfile.

Revisión de comunicación síncrona con `HttpClientFactory`, gRPC, YARP o API Gateway según arquitectura.

Revisión de comunicación asíncrona con colas, eventos, consumidores, reintentos, DLQ e idempotencia.

Detección de anti-patrones: base compartida, DTOs acoplados, llamadas en cascada, nano-servicios y transacciones distribuidas frágiles.

Creación de artifacts para describir contratos, dependencias, riesgos y tareas pendientes por servicio.

Uso de agentes paralelos para analizar varios servicios sin mezclar cambios en la misma rama.

Validación de servicios con tests unitarios, integración, contrato, contenedores y pruebas de smoke.

Revisión de despliegues, variables, secretos, configuración y health checks antes de merge.

Construcción de un microservicio .NET completo asistido por Antigravity con pruebas y documentación.

Uso de Antigravity para generar o revisar Dockerfiles multi-stage de aplicaciones ASP.NET Core, workers y APIs.

Revisión de docker compose para levantar bases, colas, caches, APIs y servicios auxiliares en laboratorio.

Generación de manifiestos Kubernetes, Helm charts o plantillas equivalentes con probes, resources, secrets y configuración.

Revisión de readiness, liveness, startup probes y health checks conectados con ASP.NET Core.

Detección de riesgos en contenedores: usuario root, imágenes pesadas, secrets en build, puertos incorrectos y variables mal expuestas.

Uso de terminal policy para controlar comandos Docker y Kubernetes que puedan afectar entornos compartidos.

Generación de runbooks para despliegue, rollback, diagnóstico y validación postdeploy.

Validación de cambios DevOps con tests, linting, dry-run o entornos de laboratorio antes de producción.

Documentación de infraestructura como artifacts revisables por DevOps y desarrollo.

Creación de un flujo Antigravity para contenerizar y preparar despliegue de una API .NET.

Uso de Antigravity para revisar pipelines de GitHub Actions, Azure Pipelines, GitLab CI o Jenkins en proyectos .NET.

Generación de workflows con restore, build, test, cobertura, análisis, empaquetado, publicación y despliegue controlado.

Revisión de variables, secrets, service connections, permisos, environments, aprobaciones y artefactos.

Detección de pasos inseguros, scripts duplicados, permisos excesivos, dependencias no fijadas y ausencia de quality gates.

Creación de pipelines diferenciados para pull request, merge, nightly, release y hotfix.

Uso del agente para explicar fallos de pipeline a partir de logs, comandos y configuración.

Generación de resúmenes de PR con cambios, pruebas ejecutadas, riesgos, archivos modificados y criterios de revisión.

Configuración de hooks para impedir que el agente dé por terminada una tarea sin ejecutar build y tests mínimos.

Integración de artifacts de Antigravity como apoyo a la revisión técnica del pull request.

Construcción de un pipeline CI/CD .NET asistido por Antigravity con quality gates y documentación.

Identificación de datos que nunca deben compartirse con el agente: secretos, tokens, claves privadas, datos personales, logs sensibles y credenciales.

Configuración de exclusiones, políticas y reglas para impedir acceso a archivos sensibles o ejecución de comandos peligrosos.

Revisión de cambios generados por agente en autenticación, autorización, roles, claims, cookies, CORS, CSP y protección de APIs.

Uso de prompts seguros que no pegan información confidencial ni payloads reales de clientes.

Evaluación de riesgos de MCP, navegador, terminal, plugins, hooks y conocimiento persistente.

Creación de flujos de revisión obligatoria para cambios en seguridad, dependencias, pipelines, migraciones y configuración.

Detección de posibles vulnerabilidades introducidas por el agente: validación débil, exposición de datos, logs excesivos y permisos amplios.

Integración de análisis de dependencias, secret scanning, SAST y revisión manual en el flujo asistido.

Preparación de un protocolo de incidente si se comparte información sensible o se ejecuta un comando no deseado.

Construcción de una checklist AppSec para uso de Antigravity en repositorios .NET.

Uso de Antigravity para revisar logging estructurado, métricas, trazas, health checks y correlation IDs en aplicaciones .NET.

Generación de instrumentación OpenTelemetry para APIs, workers, HttpClient, EF Core, colas y dependencias externas.

Revisión de dashboards, alertas, runbooks y señales operativas generadas desde el código.

Análisis de logs sintéticos o anonimizados para explicar incidencias sin exponer datos sensibles.

Creación de prompts para investigar errores de producción con evidencias controladas: stack trace, versión, endpoint, trace ID y síntoma.

Detección de logs inútiles, ruidosos, sin contexto o peligrosos por incluir datos personales.

Generación de runbooks para errores recurrentes: base de datos lenta, API externa caída, cola acumulada o despliegue defectuoso.

Revisión de SLOs, SLIs y alertas con ayuda del agente para priorizar mejoras técnicas.

Documentación de hallazgos como artifacts o Knowledge Items autorizados.

Construcción de una mejora de observabilidad para una API .NET con Antigravity, tests y documentación.

Uso de Antigravity para generar README, guías de arranque, documentación de arquitectura, diagramas y documentación de endpoints.

Creación de ADRs con contexto, problema, alternativas, decisión, consecuencias y fecha de revisión.

Generación de walkthroughs de cambios para que reviewers entiendan qué se modificó, cómo probarlo y qué riesgos existen.

Actualización de documentación cuando se modifican APIs, eventos, configuración, despliegue o reglas de negocio.

Uso de artifacts para comunicar planes, implementación, evidencias visuales, grabaciones y resúmenes de validación.

Evitación de documentación generada que suena correcta pero no coincide con el código ni con los comandos reales.

Validación de documentación ejecutando comandos, links, ejemplos, scripts y pasos de instalación.

Creación de diagramas Mermaid o C4 cuando ayudan a explicar módulos, dependencias, flujos o despliegues.

Separación entre documentación vigente, histórica, exploratoria y notas internas del agente.

Construcción de documentación técnica completa para una solución .NET asistida por Antigravity.

Uso de Antigravity como apoyo a la revisión de diffs, sin sustituir la revisión humana del desarrollador o tech lead.

Revisión de cambios por dimensiones: comportamiento, seguridad, rendimiento, testabilidad, arquitectura, estilo y compatibilidad.

Petición al agente de resúmenes de riesgo por archivo modificado, no solo una descripción superficial de cambios.

Detección de código innecesario, duplicación, dependencias nuevas, errores de nullability, async mal usado y excepciones mal gestionadas.

Revisión de cambios en Program.cs, DI, middlewares, autorización, migraciones, pipelines y configuración con especial cautela.

Generación de comentarios de revisión útiles para PRs, explicando qué cambiar y por qué importa.

Uso de tests y comandos como evidencia de que una propuesta no solo parece correcta, sino que se ha validado.

Evitación de aceptar diffs grandes sin dividirlos por intención funcional o técnica.

Creación de checklist de revisión para cambios generados por agentes en proyectos .NET.

Simulación de una revisión de pull request asistida por Antigravity con artifacts, tests y comentarios.

Uso de Antigravity para revisar paquetes NuGet, versiones, vulnerabilidades, licencias, dependencias transitivas y compatibilidad.

Generación de planes de actualización de .NET, ASP.NET Core, EF Core, librerías de testing, logging, OpenTelemetry y frontend.

Evaluación de cambios de versión mediante changelog, breaking changes, pruebas y análisis de impacto.

Detección de paquetes abandonados, innecesarios, duplicados o sustituidos por APIs modernas del framework.

Revisión de central package management, Directory.Packages.props y convenciones de versionado corporativo.

Preparación de PRs de actualización pequeños y reversibles, con tests y notas de riesgo.

Uso de hooks o pipelines para ejecutar restore, build, tests y análisis de seguridad tras cambios de dependencias.

Evitación de que el agente añada paquetes por comodidad sin justificar necesidad, mantenimiento y licencia.

Documentación de decisiones de dependencias en ADRs o notas de release.

Construcción de un flujo de actualización segura de dependencias .NET asistido por Antigravity.

Identificación de tareas repetitivas aptas para agente: crear DTOs, tests, documentación, mappers, fixtures, endpoints y scripts.

Diseño de workflows para no repetir prompts manualmente en cada repositorio o feature.

Uso de skills, reglas y hooks para convertir tareas frecuentes en procedimientos consistentes.

Automatización de generación de tests de regresión a partir de bugs cerrados.

Creación de scripts de diagnóstico para build, tests, formatos, análisis de dependencias y revisión de configuración.

Preparación de plantillas para nuevas features .NET con estructura, tests, logging, documentación y criterios de aceptación.

Evitación de automatizar tareas mal entendidas que deberían rediseñarse antes de repetirse más rápido.

Medición de ahorro real: tiempo de ciclo, errores evitados, menos retrabajo, menos PRs rechazados y onboarding más rápido.

Documentación de automatizaciones con owner, propósito, permisos y riesgos.

Construcción de un catálogo de automatizaciones Antigravity para tareas diarias de desarrollo .NET.

Uso de Antigravity para leer un issue, pedir aclaraciones, localizar código afectado y proponer un plan de resolución.

Generación de ramas, tests de regresión, cambios mínimos y walkthroughs para resolver bugs con trazabilidad.

Investigación de bugs intermitentes mediante logs, tests, reproducciones controladas y análisis de estado.

Preparación de cambios de mantenimiento: limpieza de warnings, actualización de paquetes, mejora de documentación y reducción de deuda.

Uso de MCP con sistemas de issues cuando está autorizado, manteniendo control de permisos y datos accesibles.

Conversión de conversaciones técnicas en tareas claras para agentes: reproducir, aislar, corregir, probar y documentar.

Creación de artifacts que expliquen causa raíz, pasos de reproducción, fix y validaciones ejecutadas.

Priorización de mantenimiento según criticidad, frecuencia de fallo, esfuerzo, impacto y riesgo.

Evitación de que el agente reescriba zonas amplias para arreglar un bug pequeño.

Resolución completa de un bug .NET con Antigravity, desde issue hasta PR listo para revisión.

Uso del agente para inventariar versiones de .NET, paquetes, frameworks, APIs obsoletas, proyectos legacy y dependencias.

Generación de planes de migración por fases hacia versiones actuales de .NET, ASP.NET Core, EF Core, testing y frontend.

Identificación de breaking changes, APIs deprecated, cambios de configuración, problemas de hosting y ajustes de CI/CD.

Refactorización incremental de Web Forms, MVC clásico, servicios antiguos o librerías compartidas hacia estructuras modernas.

Creación de pruebas de caracterización antes de modificar comportamiento legacy.

Preparación de migraciones con rollback, comparación de resultados, revisión de performance y validación funcional.

Uso de browser agent para comprobar visualmente pantallas modernizadas y generar evidencias.

Documentación de decisiones, deuda aceptada, pasos pendientes y riesgos de compatibilidad.

Separación entre modernización técnica que aporta valor y cambios cosméticos de bajo impacto.

Construcción de un roadmap de modernización .NET asistido por Antigravity con fases y criterios de éxito.

Diseño de una rutina diaria con Antigravity: revisar issues, abrir workspace, preparar contexto, planificar, ejecutar y validar.

Uso del agente para explicar código desconocido, revisar cambios de compañeros, preparar pruebas y documentar decisiones.

Gestión de conversaciones para no mezclar tareas, evitar contexto contaminado y conservar trazabilidad.

Uso de snippets de prompts personales alineados con reglas de equipo.

Control de interrupciones: delegar tareas largas al Agent Manager mientras se trabaja en revisiones o diseño.

Evitación de dependencia excesiva del agente para decisiones básicas que el desarrollador debe dominar.

Revisión diaria de artifacts, diffs y tests antes de cerrar tareas.

Aprendizaje incremental a partir de errores del agente, convirtiendo correcciones recurrentes en reglas o skills.

Medición personal de productividad sin confundir velocidad de generación con calidad de entrega.

Creación de un flujo personal de Antigravity para desarrollo .NET con seguridad, foco y revisión.

Diseño de un piloto controlado con repositorios no críticos, perfiles senior, objetivos claros y métricas de valor.

Selección de casos iniciales de alto retorno: generación de tests, documentación, análisis legacy, bugfixes pequeños y revisión de CI/CD.

Definición de políticas mínimas antes de escalar: permisos, reglas, hooks, MCPs aprobados, datos prohibidos y revisión humana.

Formación diferenciada para desarrolladores, QA, DevOps, AppSec, arquitectura y managers técnicos.

Creación de champions internos que mantengan reglas, skills, plugins, prompts y buenas prácticas.

Medición de impacto: tiempo de ciclo, defectos, PRs rechazados, cobertura, deuda reducida, satisfacción y riesgos detectados.

Revisión de costes, cuotas, disponibilidad, modelos y restricciones de uso por perfil.

Gestión del cambio para evitar rechazo por miedo, mal uso por exceso de confianza o fragmentación de prácticas.

Creación de un comité ligero de gobernanza para evaluar herramientas conectadas, MCPs, plugins y políticas.

Construcción de un plan de adopción de 30, 60 y 90 días para Antigravity en una organización .NET.

Definir una solución .NET de laboratorio con API ASP.NET Core, Blazor, EF Core, tests, CI/CD, Docker, documentación y bugs simulados.

Configurar Antigravity con workspace, reglas de proyecto, políticas de terminal, revisión de artifacts, navegador y comandos seguros.

Crear skills para endpoints, pruebas, Blazor, EF Core, documentación y revisión de pull requests.

Configurar hooks para build, tests, formato, protección de secretos y validación mínima antes de cerrar tareas.

Conectar un MCP de laboratorio a documentación, issues o datos simulados, aplicando permisos mínimos y trazabilidad.

Delegar una feature completa al agente: análisis, plan, implementación, tests, validación UI, artifacts y walkthrough.

Resolver un bug realista con reproducción, causa raíz, test de regresión, fix mínimo y evidencias.

Refactorizar un módulo legacy con pruebas de caracterización, cambios pequeños, revisión de diffs y documentación.

Preparar un pull request con resumen, riesgos, pruebas ejecutadas, capturas, artifacts y criterios de revisión.

Presentar el modelo final de adopción: configuración, reglas, seguridad, métricas, estándares, riesgos y roadmap para el equipo.