¿Antigravity es solo un editor con autocompletado?

No. Google lo presentó como una plataforma de desarrollo agentic que permite desplegar agentes capaces de planificar, ejecutar y verificar tareas complejas en editor, terminal y navegador.

¿Se trabaja Agent Manager?

Sí. Agent Manager es una parte central del curso. Se usa para lanzar, observar y coordinar agentes sobre tareas .NET, bugs, refactorizaciones, tests, documentación y mantenimiento.

Sí. El curso trabaja task lists, implementation plans, walkthroughs, code diffs, screenshots y browser recordings como evidencias revisables del trabajo del agente. Google describe estos artifacts como mecanismo para revisar y validar el trabajo delegado.

¿Se ve configuración de seguridad?

Sí. Se trabajan políticas de terminal, revisión de artifacts, navegador, permisos, deny lists, acceso a archivos, secretos, MCPs, hooks y reglas para limitar la autonomía del agente en repositorios .NET.

¿Se aplica a ASP.NET Core y Blazor?

Sí. El temario cubre ASP.NET Core, Minimal APIs, MVC, Razor Pages, Blazor Web App, Blazor Server, Blazor WebAssembly, EF Core, tests, CI/CD, Docker y microservicios.

Sí. Antigravity dispone de documentación específica sobre MCP y el curso lo aplica a herramientas corporativas como repositorios, issues, documentación, observabilidad y sistemas internos, siempre con permisos mínimos y controles.

¿Incluye skills, rules, hooks y plugins?

Sí. Son bloques centrales del curso. Se aprende a crear reglas, skills, hooks y plugins para estandarizar tareas .NET, validar cambios, proteger archivos sensibles y empaquetar capacidades reutilizables.

¿Se trabaja el navegador gestionado?

Sí. Se usa para validar aplicaciones web .NET, comprobar UI, capturar screenshots, generar browser recordings y revisar flujos de Blazor, Razor Pages, MVC o frontends desacoplados.

¿Hace falta saber IA avanzada?

No es imprescindible. Sí se requiere criterio técnico como desarrollador .NET. El curso enseña a dirigir agentes, revisar resultados, limitar riesgos y convertir IA en un flujo de ingeniería controlado.

¿Puede usarse en proyectos con código sensible?

Solo con políticas claras. El curso insiste en no usar secretos, datos personales, credenciales productivas ni repositorios críticos sin configuración, permisos, revisión humana y aprobación de la organización.

¿Está orientado a certificación oficial?

No. Es una formación corporativa práctica para desarrolladores .NET. Está orientada a productividad, calidad, seguridad, testing, arquitectura y adopción de agentes, no a preparar una certificación concreta.

¿Puede bonificarse por FUNDAE?

Sí. Al tratarse de una formación corporativa en desarrollo .NET, IA aplicada, productividad, testing, DevOps, seguridad y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.

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

Aprende con el curso de Antigravity para Desarrolladores .Net para empresas hasta 100% bonificado, a medida para tu organización.

Totalmente práctico y aplicable

Formación en Antigravity para Desarrolladores .Net a medida

100% bonificable a través de FUNDAE

Curso TUTORIZADO por expertos

Solicitar precio

Calcula mis créditos de FUNDAE

Solicitar precio

Calcula mis créditos de FUNDAE

Modalidad Aula Virtual Personalizada

Curso de Antigravity para Desarrolladores .Net en Aula Virtual Personalizada

Nuestra modalidad AVP es una formación en directo, práctica y 100% adaptada a vuestro equipo. No trabajamos con contenidos genéricos: diseñamos la formación en función de vuestro nivel, objetivos, procesos internos y necesidades reales de aplicación.

Solicitar información

Temario 100% a medida

Creamos el temario desde cero a partir de vuestras necesidades, nivel del equipo y objetivos concretos, priorizando aquellos contenidos que realmente aporten valor en el día a día.

Proyectos personalizados

Durante la formación trabajaremos con archivos, ejemplos, informes o procesos similares a los que utiliza vuestro equipo, para que el aprendizaje sea directamente aplicable al puesto de trabajo.

Sesiones en directo con consultor experto

Un formador especialista imparte las clases en tiempo real, resolviendo dudas, revisando casos concretos y adaptando el ritmo de la formación a la evolución del grupo.

Calendario adaptado a vuestra disponibilidad

Definimos conjuntamente fechas, horarios y duración de las sesiones para facilitar la asistencia del equipo y minimizar el impacto en la operativa diaria de la empresa.

Bonificación FUNDAE

Curso de Antigravity para Desarrolladores .Net hasta 100% Bonificable a través de FUNDAE

Tu bonificación paso a paso

Forma a tu equipo sin costes mediante la bonificación estatal.
Este programa de Antigravity para Desarrolladores .Net para empresas es subvencionable hasta el 100%.

Potencia las habilidades de edición y automatización de tus profesionales.
Accede a una formación avanzada en Antigravity para Desarrolladores .Net práctica y orientada a resultados.
Prepara a tu equipo para los retos documentales del entorno laboral actual.
Gestionamos gratis tu bonificación de este curso corporativo de Antigravity para Desarrolladores .Net ante FUNDAE.

Hablar con un asesor

01.

Calcula tu bonificación

02.

Revisamos tu caso

03.

Preparamos la gestión

04.

Tu equipo realiza el curso

05.

Aplicas la bonificación

Hablar con un asesor

La formación que decides
te devuelve dinero

Todos nuestros cursos son bonificables a través de FUNDAE.
Gestionamos toda la documentación por ti.

100%Tramitación incluida

48hTiempo medio de gestión

9,4Satisfacción general

Calcula tu crédito aproximado

Empleados a formar10

Crédito bonificable estimado

420€*

*Cálculo orientativo

Confirmar mi crédito

Impacto real

Acelera tareas reales sin perder control

Implanta Antigravity en tu organización con un plan A Medida para orquestar agentes IA, formación tutorizada para tu equipo y bonificable por FUNDAE. Infórmate.

Refuerza calidad en proyectos .NET El programa aplica agentes a ASP.NET Core, Blazor, EF Core, testing, microservicios, CI/CD y observabilidad. Esto permite mejorar código y procesos sin reducir la exigencia técnica.

Mejora revisión y trazabilidad Los artifacts, walkthroughs, capturas, browser recordings y resúmenes de cambios facilitan revisar qué hizo el agente y por qué. Esto reduce la opacidad típica de herramientas de IA aplicadas al desarrollo.

Aporta seguridad y gobierno El curso incluye políticas de terminal, navegador, revisión, MCP, hooks, plugins, secrets, datos sensibles y uso responsable. La productividad no se plantea a costa de abrir riesgos innecesarios.

Estandariza el uso en equipos Rules, skills, hooks, plugins y prompts corporativos permiten que varios desarrolladores trabajen con patrones comunes. Esto evita que cada persona use Antigravity de forma distinta y difícil de mantener.

Ayuda a modernizar legacy Antigravity puede acelerar comprensión de código heredado, generación de pruebas de caracterización, análisis de dependencias y refactorizaciones por fases. El curso enseña a hacerlo sin caer en reescrituras peligrosas.

Conecta desarrollo, QA y DevOps La formación cubre código, pruebas, navegador, pipelines, Docker, documentación, seguridad y observabilidad. Esto permite que Antigravity sea útil para todo el ciclo de entrega, no solo para escribir clases C#.

Solicitar propuesta sin coste

Personaliza el temario al 100% para tu equipo

Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.

Agendar cita con CTOAgendar cita con CTO

Nuestra plataforma

Nueva Plataforma
de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje

Acceso a las grabaciones

Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.

Recursos formativos

Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.

Confirmación de asistencia

La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.

Ejercicios prácticos

Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.

Acceso a las grabaciones

Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.

Recursos formativos

Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.

Confirmación de asistencia

La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.

Ejercicios prácticos

Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.

Practica y mejora con nuestra plataforma

Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.

Correccion magica

Feedback inteligente

Aprende de cada acierto y fallo con explicaciones claras

Me interesa

Programa formativo

Temario del curso

Encuentra todo el temario del curso aquí.

Temario

Comprensión de Antigravity como plataforma orientada a agentes, no como un simple autocompletador de código o chat lateral dentro del editor.
Diferenciación entre pedir ayuda puntual a la IA y delegar una tarea completa con planificación, ejecución, verificación, artefactos y revisión humana.
Identificación de casos de uso reales en .NET: crear endpoints, corregir bugs, generar tests, revisar arquitectura, documentar APIs, analizar legacy y validar UI.
Análisis de los límites de autonomía que debe tener un agente cuando trabaja sobre código C#, terminal, navegador, tests y repositorios de empresa.
Revisión del impacto de Antigravity en el flujo diario: menos cambio de contexto, más capacidad de investigación y mayor necesidad de criterios de revisión.
Comparación entre trabajo síncrono en el editor y trabajo asíncrono mediante agentes gestionados desde el Agent Manager.
Definición de responsabilidades humanas: el agente propone y ejecuta bajo límites; el desarrollador valida, decide, aprueba y asume el criterio técnico.
Evaluación de riesgos de adopción: cambios demasiado grandes, comandos peligrosos, pruebas insuficientes, exposición de datos y confianza excesiva.
Creación de una primera guía de uso para equipos .NET con usos permitidos, usos restringidos, validaciones mínimas y revisión obligatoria.
Preparación de un flujo base para convertir una petición funcional en plan, cambios, tests, artifacts y pull request revisable.

Comprensión de Antigravity como plataforma orientada a agentes, no como un simple autocompletador de código o chat lateral dentro del editor.
Diferenciación entre pedir ayuda puntual a la IA y delegar una tarea completa con planificación, ejecución, verificación, artefactos y revisión humana.
Identificación de casos de uso reales en .NET: crear endpoints, corregir bugs, generar tests, revisar arquitectura, documentar APIs, analizar legacy y validar UI.
Análisis de los límites de autonomía que debe tener un agente cuando trabaja sobre código C#, terminal, navegador, tests y repositorios de empresa.
Revisión del impacto de Antigravity en el flujo diario: menos cambio de contexto, más capacidad de investigación y mayor necesidad de criterios de revisión.
Comparación entre trabajo síncrono en el editor y trabajo asíncrono mediante agentes gestionados desde el Agent Manager.
Definición de responsabilidades humanas: el agente propone y ejecuta bajo límites; el desarrollador valida, decide, aprueba y asume el criterio técnico.
Evaluación de riesgos de adopción: cambios demasiado grandes, comandos peligrosos, pruebas insuficientes, exposición de datos y confianza excesiva.
Creación de una primera guía de uso para equipos .NET con usos permitidos, usos restringidos, validaciones mínimas y revisión obligatoria.
Preparación de un flujo base para convertir una petición funcional en plan, cambios, tests, artifacts y pull request revisable.

¿Tienes dudas?

Estamos aquí para ayudarte

Reservar plaza

Tema 1: Antigravity como plataforma agentic para desarrollo .NET

Comprensión de Antigravity como plataforma orientada a agentes, no como un simple autocompletador de código o chat lateral dentro del editor.
Diferenciación entre pedir ayuda puntual a la IA y delegar una tarea completa con planificación, ejecución, verificación, artefactos y revisión humana.
Identificación de casos de uso reales en .NET: crear endpoints, corregir bugs, generar tests, revisar arquitectura, documentar APIs, analizar legacy y validar UI.
Análisis de los límites de autonomía que debe tener un agente cuando trabaja sobre código C#, terminal, navegador, tests y repositorios de empresa.
Revisión del impacto de Antigravity en el flujo diario: menos cambio de contexto, más capacidad de investigación y mayor necesidad de criterios de revisión.
Comparación entre trabajo síncrono en el editor y trabajo asíncrono mediante agentes gestionados desde el Agent Manager.
Definición de responsabilidades humanas: el agente propone y ejecuta bajo límites; el desarrollador valida, decide, aprueba y asume el criterio técnico.
Evaluación de riesgos de adopción: cambios demasiado grandes, comandos peligrosos, pruebas insuficientes, exposición de datos y confianza excesiva.
Creación de una primera guía de uso para equipos .NET con usos permitidos, usos restringidos, validaciones mínimas y revisión obligatoria.
Preparación de un flujo base para convertir una petición funcional en plan, cambios, tests, artifacts y pull request revisable.

Tema 2: Instalación, primer arranque y configuración inicial segura

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.

Tema 3: Workspaces, proyectos y organización de repositorios .NET

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.

Tema 4: Agent Manager: orquestación de agentes para tareas .NET

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.

Tema 5: Editor View: trabajo directo sobre código C# y Razor

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.

Tema 6: Modelos, modos de razonamiento y selección por tarea

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.

Tema 7: Políticas de terminal, navegador y revisión de artefactos

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.

Tema 8: Reglas locales, globales y estándares de equipo

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.

Tema 9: Skills para tareas repetibles en desarrollo .NET

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.

Tema 10: Hooks para validación automática y control técnico

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.

Tema 11: MCP para conectar Antigravity con herramientas corporativas

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.

Tema 12: Plugins y empaquetado de capacidades para equipos .NET

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.

Tema 13: Knowledge Items y memoria técnica del proyecto

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.

Tema 14: CLI de Antigravity y uso desde terminal

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.

Tema 15: Prompting profesional para agentes en proyectos .NET

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.

Tema 16: Análisis de soluciones C# grandes y legacy

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.

Tema 17: Desarrollo de APIs ASP.NET Core con agentes

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.

Tema 18: Desarrollo Blazor con Antigravity

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.

Tema 19: Entity Framework Core, datos y persistencia asistida

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.

Tema 20: Testing unitario en .NET con ayuda de Antigravity

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.

Tema 21: Testing de integración, APIs y TestServer con agentes

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.

Tema 22: Selenium, Playwright y validación UI con Antigravity

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.

Tema 23: Depuración de errores .NET con agentes

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.

Tema 24: Refactorización segura y reducción de deuda técnica

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.

Tema 25: Arquitectura hexagonal, DDD, CQRS y EDA con Antigravity

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.

Tema 26: Microservicios .NET y tareas distribuidas con agentes

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.

Tema 27: Docker, Kubernetes y DevOps para proyectos .NET

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.

Tema 28: CI/CD, pipelines y pull requests asistidos

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.

Tema 29: Seguridad, secretos y uso responsable de agentes

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.

Tema 30: Observabilidad, logging y diagnóstico operativo

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.

Tema 31: Documentación técnica, ADRs y walkthroughs

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.

Tema 32: Revisión de código, diffs y calidad técnica

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.

Tema 33: Gestión de paquetes NuGet, dependencias y actualizaciones

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.

Tema 34: Automatización de tareas repetitivas del desarrollador .NET

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.

Tema 35: Trabajo con issues, bugs y mantenimiento evolutivo

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.

Tema 36: Modernización de proyectos .NET con Antigravity

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.

Tema 37: Productividad personal y flujo diario del desarrollador

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.

Tema 38: Adopción empresarial de Antigravity en equipos .NET

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.

Tema 39: Proyecto final integrador: plataforma .NET asistida por Antigravity

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.

Perfiles profesionales

Pensado para quienes deben dominar Antigravity para Desarrolladores .Net en su día a día

Desarrolladores backend .NET

Este curso encaja con desarrolladores que trabajan con C#, ASP.NET Core, APIs, servicios, workers, Entity Framework Core o microservicios y quieren usar Antigravity para acelerar tareas reales sin perder control técnico. Aprenderán a pedir análisis de código, generar cambios por fases, revisar diffs, validar tests, corregir errores, documentar decisiones y mantener una supervisión humana sólida.

Desarrolladores Blazor y full stack .NET

Los perfiles que combinan frontend y backend podrán usar Antigravity para trabajar con Blazor, Razor Components, MVC, Razor Pages, Bootstrap, JavaScript interop, APIs y formularios empresariales. La formación les ayuda a usar el navegador gestionado, capturas, walkthroughs y validación visual para comprobar que los cambios no solo compilan, sino que funcionan en la interfaz.

Tech leads y desarrolladores senior

Los perfiles con responsabilidad técnica podrán definir reglas, skills, workflows, políticas de revisión, criterios de seguridad y estándares de uso de agentes para el equipo. El valor está en convertir Antigravity en una herramienta de ingeniería gobernada, evitando que cada desarrollador la use de forma distinta, insegura o difícil de auditar.

Equipos que mantienen aplicaciones legacy .NET

Los equipos con monolitos, Web Forms, MVC clásico, servicios antiguos, deuda técnica o tests insuficientes podrán usar Antigravity para comprender código heredado, detectar dependencias, proponer refactorizaciones, generar pruebas de caracterización y preparar migraciones graduales sin reescrituras impulsivas.

QA automation y SDET en entornos .NET

Los perfiles de calidad podrán aplicar Antigravity a generación y revisión de pruebas xUnit, NUnit, MSTest, TUnit, Selenium, Playwright, integración, APIs y CI/CD. La formación les permite pedir escenarios, detectar huecos de cobertura, mejorar aserciones y validar flujos con evidencias generadas por el agente.

DevOps, plataforma y AppSec

Los perfiles de DevOps y seguridad podrán participar en la configuración de terminal policies, browser policies, artifact review, MCP, hooks, plugins, permisos, secretos, comandos permitidos y automatizaciones. El curso les da criterios para permitir productividad sin abrir riesgos innecesarios sobre repositorios, pipelines o infraestructura.

¿Tienes dudas?

ContáctanosContacta con nosotros

Casos de éxito

Empresas que ya han formado a sus equipos

Experiencias reales de equipos que ya han trabajado con nosotros.

+16

años de liderazgo

+3.500

empresas formadas

Nuestra empresa decidió contratar formación con Imagina aprovechando los créditos de FUNDAE, y fue una gran decisión. La modalidad online nos permitió adaptar los horarios a nuestro equipo. La formación ha sido práctica, clara y útil para el día a día. Es sencillo de gestionar y los resultados son excepcionales.

Hugo Gutiérrez

Analista Financiero

Gracias a Imagina, la eficiencia de nuestras sesiones de capacitación ha mejorado drásticamente. Es sencillo de usar y los resultados son excepcionales.

Luis Martínez

Administrativo

Gracias al aula virtual de Imagina siempre son capaces de adaptar los cursos a nuestras necesidades. El contenido fue muy completo y práctico.

Elena Pérez

Responsable de Recursos Humanos

Mejor de lo esperado, la modalidad online se adapta a nuestros horarios. La ayuda con la bonificación FUNDAE hizo todo más fácil. Práctico y necesario.

Alejandro Sánchez

Director de Operaciones

Hugo Gutiérrez

Analista Financiero

Gracias a Imagina, la eficiencia de nuestras sesiones de capacitación ha mejorado drásticamente. Es sencillo de usar y los resultados son excepcionales.

Luis Martínez

Administrativo

Gracias al aula virtual de Imagina siempre son capaces de adaptar los cursos a nuestras necesidades. El contenido fue muy completo y práctico.

Elena Pérez

Responsable de Recursos Humanos

Mejor de lo esperado, la modalidad online se adapta a nuestros horarios. La ayuda con la bonificación FUNDAE hizo todo más fácil. Práctico y necesario.

Alejandro Sánchez

Director de Operaciones

+16

años de liderazgo

+3.500

empresas formadas

Hugo Gutiérrez

Analista Financiero

Gracias a Imagina, la eficiencia de nuestras sesiones de capacitación ha mejorado drásticamente. Es sencillo de usar y los resultados son excepcionales.

Luis Martínez

Administrativo

Gracias al aula virtual de Imagina siempre son capaces de adaptar los cursos a nuestras necesidades. El contenido fue muy completo y práctico.

Elena Pérez

Responsable de Recursos Humanos

Mejor de lo esperado, la modalidad online se adapta a nuestros horarios. La ayuda con la bonificación FUNDAE hizo todo más fácil. Práctico y necesario.

Alejandro Sánchez

Director de Operaciones

Hugo Gutiérrez

Analista Financiero

Gracias a Imagina, la eficiencia de nuestras sesiones de capacitación ha mejorado drásticamente. Es sencillo de usar y los resultados son excepcionales.

Luis Martínez

Administrativo

Gracias al aula virtual de Imagina siempre son capaces de adaptar los cursos a nuestras necesidades. El contenido fue muy completo y práctico.

Elena Pérez

Responsable de Recursos Humanos

Mejor de lo esperado, la modalidad online se adapta a nuestros horarios. La ayuda con la bonificación FUNDAE hizo todo más fácil. Práctico y necesario.

Alejandro Sánchez

Director de Operaciones

480.000 alumnos formados en Imagina

Ver todas las opiniones

Preguntas frecuentes

Resolvemos todas tus dudas sobre nuestra formación en Antigravity para Desarrolladores .Net

Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.

Sí. El curso se centra en Google Antigravity como plataforma agentic de desarrollo para trabajar con agentes sobre editor, terminal, navegador, artifacts, Agent Manager, reglas, skills, hooks, MCP, plugins y proyectos .NET.

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

¿Tienes dudas?
Estamos aqui para ayudarte

Contactar

Recursos extra

Descubre nuestros tutoriales

Automatización con Microsoft

Qué es Microsoft Power Automate y para qué sirve

November 05, 2025

Descubre Que es Microsoft Power Automate o Microsoft Flow: Guía Completa de la Herramienta de Automatización de Tareas de Microsoft

Seguridad

¿Qué es Kali Linux y para qué se utiliza?

June 17, 2025

Descubre cómo instalar Kali Linux fácilmente y empieza a usar esta herramienta esencial para pruebas de penetración y análisis forense digital.

Recursos Humanos

Top 5 Cursos Bonificados para Trabajadores en 2025

June 09, 2025

Conoce los cursos bonificados para trabajadores 2025 más demandados y cómo puedes inscribir a tus empleados para aprovechar los créditos formativos de FUNDAE.

Prevención

5 Cursos Obligatorios para cualquier Empresa en 2025

May 26, 2025

Conoce los cursos obligatorios para empresas 2025 y cómo asegurar que tu organización cumpla con las normativas actuales sin riesgos de sanciones.

Recursos Humanos

Cursos Bonificados por Fundación Tripartita en 2025

May 05, 2025

Descubre los mejores cursos bonificados para empresas en 2025 por la Fundación Tripartita. Aumenta la productividad de tu equipo sin costes adicionales.

Recursos extra

Para que aprendas mensualmente
con nosotros

Tutoriales

Nuestra colección de contenido educacional

Qué es Microsoft Power Automate y para qué sirve

¿Qué es Kali Linux y para qué se utiliza?

Top 5 Cursos Bonificados para Trabajadores en 2025

5 Cursos Obligatorios para cualquier Empresa en 2025

Cursos Bonificados por Fundación Tripartita en 2025

Da el salto y aprende con nuestros cursos

Solicita información

Diseñemos hoy el curso que tu empresa necesita

Cuéntanos tus objetivos de negocio y prepararemos una propuesta formativa bonificable totalmente ad hoc

Solicitar presupuesto personalizado

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

Aprende con el curso de Antigravity para Desarrolladores .Net para empresas hasta 100% bonificado, a medida para tu organización.

Modalidad Aula Virtual Personalizada

Curso de Antigravity para Desarrolladores .Net hasta 100% Bonificable a través de FUNDAE

Tu bonificación paso a paso

La formación que decideste devuelve dinero

Acelera tareas reales sin perder control

Refuerza calidad en proyectos .NET El programa aplica agentes a ASP.NET Core, Blazor, EF Core, testing, microservicios, CI/CD y observabilidad. Esto permite mejorar código y procesos sin reducir la exigencia técnica.

Mejora revisión y trazabilidad Los artifacts, walkthroughs, capturas, browser recordings y resúmenes de cambios facilitan revisar qué hizo el agente y por qué. Esto reduce la opacidad típica de herramientas de IA aplicadas al desarrollo.

Aporta seguridad y gobierno El curso incluye políticas de terminal, navegador, revisión, MCP, hooks, plugins, secrets, datos sensibles y uso responsable. La productividad no se plantea a costa de abrir riesgos innecesarios.

Estandariza el uso en equipos Rules, skills, hooks, plugins y prompts corporativos permiten que varios desarrolladores trabajen con patrones comunes. Esto evita que cada persona use Antigravity de forma distinta y difícil de mantener.

Ayuda a modernizar legacy Antigravity puede acelerar comprensión de código heredado, generación de pruebas de caracterización, análisis de dependencias y refactorizaciones por fases. El curso enseña a hacerlo sin caer en reescrituras peligrosas.

Conecta desarrollo, QA y DevOps La formación cubre código, pruebas, navegador, pipelines, Docker, documentación, seguridad y observabilidad. Esto permite que Antigravity sea útil para todo el ciclo de entrega, no solo para escribir clases C#.

Personaliza el temario al 100% para tu equipo

Nueva Plataformade E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Ejercicios prácticos

Acceso a las grabaciones

Recursos formativos

Confirmación de asistencia

Ejercicios prácticos

Practica y mejora con nuestra plataforma

Temario del curso

Pensado para quienes deben dominar Antigravity para Desarrolladores .Net en su día a día

Empresas que ya han formado a sus equipos

Resolvemos todas tus dudas sobre nuestra formación en Antigravity para Desarrolladores .Net

Descubre nuestros tutoriales

Qué es Microsoft Power Automate y para qué sirve

¿Qué es Kali Linux y para qué se utiliza?

Top 5 Cursos Bonificados para Trabajadores en 2025

5 Cursos Obligatorios para cualquier Empresa en 2025

Cursos Bonificados por Fundación Tripartita en 2025

Para que aprendas mensualmentecon nosotros

Nuestra colección de contenido educacional

Da el salto y aprende con nuestros cursos

Diseñemos hoy el curso que tu empresa necesita

Temario del curso

La formación que decides
te devuelve dinero

Nueva Plataforma
de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje

Para que aprendas mensualmente
con nosotros