Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA en español / Adiós a la depuración a parches: modo agente de GitHub Copilot para .NET y Azure (Doblaje IA)
Transcript
- 0:00Listo para 10 días de Microsoft 365, Copilot y App, Azure y las personas que están dando forma al futuro del trabajo.
- 0:07Este enero, regresa a MM35 con y venimos a lo grande.
- 0:11Y venimos a lo grande.
- 0:12Únete a nosotros para sesiones en vivo, demostraciones reales y conocimientos prácticos de MVP y expertos de la industria de todo el mundo.
- 0:18Nada de diapositivas genéricas, nada de parada eliminable.
- 0:22Abordaremos desafíos reales.
- 0:23Copilots Studio, agentes de IA, Fabric, seguridad, gobernanza y automatización.
- 0:28Tanto si eres profesional de TI, desarrollador o líder empresarial, hay sesiones diseñadas para ti.
- 0:35Con 10 días completos, puedes explorar múltiples tecnologías y conectar con una comunidad global.
- 0:40Mira en vivo y lleva ideas prácticas de vuelta a tu organización.
- 0:45Enero de 2027, 10 días, una comunidad de Microsoft.
- 0:49El registro ya está abierto.
- 0:51Ve a m365com.net y asegura tu lugar hoy mismo.
- 0:56Eso es m365com.net.
- 0:59Únete ahora en m365com.net y nos vemos en vivo en enero.
- 1:05Si alguna vez has abierto una solución y te has sentido abrumado al instante por la red de archivos, referencias y errores esperando en buscarte, no estás solo.
- 1:12La mayoría de los desarrolladores trabajan de forma reactiva, pacheando aquí y depurando allá.
- 1:15El modo agente de GitHub Copilot tiene como objetivo mantener un contexto más amplio y coordinar cambios en varios archivos.
- 1:20En este video demostraremos cómo se ve ese flujo de trabajo dentro de un proyecto real de DonTonet y Azure.
- 1:25Analizaremos una solución en vivo y mostraremos el antes y el después de los cambios de la agenda.
- 1:28Verás cómo generar código para múltiples archivos con menos esfuerzo, resolver errores entre archivos más rápido e incluso usar lenguaje natural para estructurar funciones.
- 1:36Y antes de llegar a eso, comencemos con el costo oculto del ciclo de depuración en el que muchos de nosotros vimos a diario.
- 1:41El costo oculto de la depuración por parte
- 1:43Te sientas a corregir un error que parece bastante simple.
- 1:46La aplicación no compila y la consola marca una línea en tu archivo principal de proyecto.
- 1:50Ajustas el método, recompilas y crees que lo has resuelto hasta que el mismo mensaje reaparece de forma ligeramente distinta.
- 1:56Pasa otra media hora antes de que detectes el problema real.
- 1:59Una dependencia faltante escondida en otra carpeta del proyecto.
- 2:02Para cuando corriges la referencia y vuelves a implementar, gran parte de tu tarde se ha disuelto en parches.
- 2:07El trabajo de funciones que planeaste se pospone para mañana.
- 2:09El patrón es tan común que parece normal.
- 2:12En la superficie avanzas porque cada error que eliminas se siente como una victoria.
- 2:16La práctica está dando vueltas en cero.
- 2:17El ciclo es programar, compilar, error, corregir, repetir.
- 2:21Las horas se desvanecen persiguiendo un rastro de causa y efecto
- 2:23y el resultado neto es progreso reactivo en lugar de mejoras significativas.
- 2:27¿Cuántos de ustedes han perdido una tarde entera en este mismo ciclo?
- 2:29Deja un comentario brevele a la respuesta más destacada.
- 2:32Lo que hace este ciclo agotador es que las herramientas que nos rodean siguen avanzando, pero el patrón no.
- 2:37Los editores añaden funciones, los marcos evolucionan y las integraciones son más profundas,
- 2:41pero depurar sigue exigiendo un enfoque reactivo.
- 2:44Es como intentar frenar un incendio creciente con un balde de agua.
- 2:47Cada brote se controla al momento, pero las condiciones que lo provocaron permanecen,
- 2:50casi garantizando la siguiente llamarada.
- 2:52Y con cada cambio de pestaña, el costo oculto aumenta.
- 2:55Pasas de una casa de servicio a un archivo de configuración y luego saltas a un gráfico de dependencias.
- 3:00Cada cambio te saca del hilo lógico que sigues obligándote a un reinicio mental.
- 3:04No son solo los segundos al cambiar de ventana,
- 3:06es el desgaste mental de reconstruir el contexto una y otra vez.
- 3:10A lo largo del día, esos pequeños reinicios se acumulan en algo pesado.
- 3:13Para los desarrolladores individuales, la fatiga se manifiesta como frustración y tiempo perdido.
- 3:17Para los equipos en proyectos empresariales, el impacto se multiplica.
- 3:20Los ciclos de depuración desvían los objetivos del sprint,
- 3:22que trazan lanzamientos y crean una acumulación que crece más rápido de lo que se reduce.
- 3:26El fortalecimiento de la deuda técnica es solo otro efecto secundario de las horas perdidas apagando fuegos.
- 3:31Muchos equipos informan que una gran parte de su tiempo de desarrollo se consume en depuración reactiva.
- 3:35No es la parte emocionante de la ingeniería.
- 3:37Nadie planifica una hoja de ruta en torno a perseguir cinco veces la misma discrepancia de dependencias.
- 3:41Sin embargo, ahí es donde se va el ancho de banda, semana tras semana.
- 3:44Cuando corregir errores se vuelve la definición de progreso,
- 3:47crear nuevas funciones pasa a segundo plano
- 3:48y la arquitectura sufre silenciosamente.
- 3:51La verdad incómoda es que la depuración improvisada no solo ralentiza las cosas,
- 3:55refuerza una cultura de reacción en lugar de diseño.
- 3:58Pasas el tiempo apagando llamas, no construyendo sistemas.
- 4:02Eso puede mantener el producto a flote a corto plazo,
- 4:04pero limita la escalabilidad del equipo y la confianza al lanzar.
- 4:08Detengamos en esa imagen, apagar incendios.
- 4:10Corre al foco, echar agua y seguir adelante.
- 4:12El problema no es que los desarrolladores no sean buenos en eso.
- 4:15Lo son.
- 4:16El problema es que las llamas nunca se detienen realmente.
- 4:17Solo se mueven apareciendo nuevos archivos, proyectos y configuraciones,
- 4:21manteniendo a todos en modo respuesta en lugar de creación.
- 4:25Eso plantea la pregunta, ¿qué pasaría si el ciclo no dependiera solo de ti?
- 4:29¿Qué pasaría si las partes repetitivas, el ciclo de rastrear, cambiar y parchear,
- 4:33pudieran gestionarse de otra forma mientras tú te enfocas en construir?
- 4:36Porque si bien la presión de apagar incendios es obvia, hay otro punto crítico que aún no hemos tocado.
- 4:41El verdadero peso llega cuando tu proyecto no es solo un archivo o un módulo.
- 4:45Es cuando la solución que necesitas abarca varias capas a la vez.
- 4:48Imagina abrir una solución, donde la lógica se extiende, por diferentes proyectos, servicios y bibliotecas.
- 4:53La pieza que necesitas vive en tres lugares al mismo tiempo.
- 4:57Mantenerla clara en tu mente es toda una batalla.
- 5:01Caos entre múltiples archivos frente al control de contexto de la IA.
- 5:04Cuando los proyectos abarcan múltiples capas, el verdadero desafío no es escribir código,
- 5:08es mantener unidas todas las partes móviles.
- 5:11Aquí es donde la tensión entre el caos de múltiples archivos y el control de contexto por IA se muestra más claramente.
- 5:16Toma una solución tu net grande con una docena o más de proyectos.
- 5:19Cualquier función nueva suele tocar diferentes capas a la vez.
- 5:22Un controlador en un lugar, un servicio en otro y un conjunto de archivos de configuración que viven en otra parte.
- 5:27Antes de escribir una sola línea, pasas tiempo rastreando referencias y verificando dependencias,
- 5:32esperando que un pequeño cambio no provoque errores inesperados más adelante.
- 5:36Ese flujo de trabajo no es una excepción.
- 5:37Es normal en aplicaciones empresariales, especialmente cuando los servicios de Azure y las integraciones entran en escena.
- 5:42La estructura de estos sistemas no es plana.
- 5:44Las interfaces, los mapeos de inyección de dependencias y las referencias entre proyectos juegan un papel importante.
- 5:50Con Azure en la mezcla, algunas dependencias salen completamente de la cárpeta de la solución,
- 5:53aplicaciones de funciones, enlaces de bus de servicio, configuraciones de recursos y conexiones de recursos y conexiones de almacenamiento.
- 5:59Estás coordinando entre código en tu IDE, archivos de configuración en disco y servicios definidos en la nube.
- 6:04A ninguno le importa que quisiera hacer menos clics.
- 6:06Cada vez que cambias de contexto, consumas energía reconstruyendo la visión general.
- 6:10La mayoría de nosotros intentamos manejar ese contexto en la memoria de Tron.
- 6:12Al principio es manejable, pero a medida que el proyecto crece, los errores se cuelan.
- 6:16Agregas un nuevo método en el servicio, pero olvidas su registro de DDI.
- 6:19Programas una función de Azure y más tarde te das cuenta de que el enlace nunca se agregó al host.json o a la plantilla de incrementación.
- 6:25Nada te avisa hasta el tiempo de ejecución cuando estás depurando en lugar de construir.
- 6:28El código en sí mismo no es la parte difícil.
- 6:30Es la coordinación entre archivos.
- 6:32Todos conocen la sensación de saltar entre pestañas.
- 6:34De un controlador a un servicio, luego a un modelo, después a archivos de configuración y de vuelta,
- 6:38solo para perder el rastro de por qué abriste ese archivo.
- 6:41Es una pequeña interrupción que se repite ocenas de veces en DDI.
- 6:45Esas interacciones se acumulan, creando una fricción que ralentiza el progreso real.
- 6:48El resultado es una entrega más lenta, no porque escribirse a lento, sino porque mantener todo sincronizado o al enfoque.
- 6:54Esta carga de trabajo crece en proyectos diseñados para DDI.
- 6:56Azure distribuye configuraciones clave en varios lugares.
- 6:59Archivos de configuración locales, variables de entorno, plantillas a RM o BICEP y canalizaciones CI, CD, CD.
- 7:06Lo que parece una simple solicitud de función a menudo se extiende por cuatro capas de abstracción.
- 7:11La complejidad no es opcional.
- 7:12Está integrada en la forma en que funciona el ecosistema.
- 7:15Aquí es donde el modo agente se presenta como un cambio potencial.
- 7:18En lugar de dejarle toda esa orquestación a usted, está diseñado para mantener un contexto más amplio entre múltiples archivos.
- 7:23No significa que cuando solicita un cambio en una capa, no ignora a las demás.
- 7:26En la demostración, crearé una nueva función de Azure y mostraré cómo ayuda a la gente generando el cuerpo del método, creando la configuración de enlace, actualizando host, ASON e incluso sugiriendo registro de dependencias correcto.
- 7:38Por lo general, es un proceso de varios pasos dispersos en diferentes archivos.
- 7:41Un agente puede simplificarlo todo en un solo flujo.
- 7:44No se trata de reemplazar su criterio, sino de eliminar el trabajo administrativo repetitivo para que pueda enfocarse en las decisiones de diseño.
- 7:50Los humanos podemos mantener un esquema general en la mente o dibujar una pizarra.
- 7:54Una IA puede rastrear los detalles archivo por archivo sin perder el hilo.
- 7:58Lo que para nosotros supone una gran carga cognitiva es solo contexto base para la gente.
- 8:02La diferencia en la práctica es pasar de hacer malabares con pestañas a cambios orquestados que se mantienen sincronizados.
- 8:07También mostraré el pull request o la diferencia creada por el agente durante la demo para que vea exactamente qué ediciones se hicieron.
- 8:12Esa visibilidad es importante.
- 8:14Usted mantiene el control total para revisar y aprobar, mientras el trabajo, pese a actualizar varios archivos, se hace por usted.
- 8:18Así, en lugar de pasar la tarde uniendo fragmentos, dirige el cambio una vez, confirma las actualizaciones generadas y pasa al diseño de alto nivel y pasa a alto nivel.
- 8:26El alivio no está solo en ahorrar clics o teclas, sino en mantener el enfoque en resolver problemas reales en lugar de recordar cómo se conectan a una docena de archivos.
- 8:34Esta ventaja se nota más cuando las cosas fallan, porque incluso con un mejor manejo del contexto los sistemas fallan, las configuraciones se debían, las referencias incorrectas reaparecen.
- 8:41Y ahí es donde comienza la siguiente prueba, cómo se rastrean y resuelven los errores una vez que aparecen.
- 8:47De la búsqueda de errores a soluciones autónomas.
- 8:49Piensa en cuántas veces ha visto un mensaje de error que apunta directamente a un solo archivo.
- 8:53Sigue el seguimiento de pila hasta el método que menciona, hace un pequeño ajuste y vuelve a compilar.
- 8:58Parece la solución obvia, hasta que el mismo error aparece de nuevo, solo que de una forma ligeramente distinta.
- 9:03Es entonces cuando se da cuenta de que el seguimiento de pila es solo mostrador.
- 9:06El problema real vive en otra parte, tal vez en una clase de soporte o escondido en un archivo de configuración que no ha abierto en toda la semana.
- 9:12Todo desarrollador se ha enfrentado a ese tipo de desorientación.
- 9:14Lo que parece ser el problema no es donde realmente debe aplicarse la solución.
- 9:17Esto consume tiempo rápidamente.
- 9:18Ajustas una cosa, recompilas y espera.
- 9:20Luego aparece un nuevo error que te lleva a otro archivo, otro ajuste y otra recompilación.
- 9:25El ciclo parece productivo porque estás en movimiento, escribiendo y recompilando.
- 9:28Pero en el fondo es más ensayo y error que una solución real.
- 9:32Ese ciclo puede absorber horas, dejándote con pequeñas correcciones superficiales,
- 9:36pero sin avanzar realmente en la función con la que empezaste.
- 9:38El costo real aquí es la oportunidad.
- 9:40Mientras estás atrapado en el ritmo de recompilar y reintentar,
- 9:43no estás resolviendo problemas de negocio ni lanzando la funcionalidad que tus usuarios esperan.
- 9:48El impulso se pierde en conjeturas en lugar de diseño.
- 9:50Se siente activo en el momento, pero esas horas no suman mucho más allá de evitar que el sistema se rompa.
- 9:56En un equipo, este movimiento superficial ralentiza todo y crea un atraso de funciones que siguen posponiéndose.
- 10:00Aquí es donde un flujo de trabajo con agentes empieza a verse diferente.
- 10:05La idea no es detenerse en la línea que destaca tu rastro de pila.
- 10:08En cambio, está diseñado para mantener el contexto a nivel de sistema,
- 10:11preguntando no solo qué debería hacer este archivo,
- 10:13sino qué secuencia de cambios se necesita en las partes conectadas para restaurar la consistencia.
- 10:18En la práctica, esto significa que puedes verlo o proponer ediciones que abarcan múltiples archivos.
- 10:22Por ejemplo, verás en la demostración que cuando un método requiere cambios,
- 10:25puedes sugerir ediciones coincidentes en configuraciones relacionadas o plantillas de despliegue,
- 10:29en lugar de dejar que tú las busques.
- 10:31Ese es el salto del autocompletado a algo más amplio.
- 10:34El autocompletado termina líneas.
- 10:35Un agente coordina entre archivos y esa coordinación importa más
- 10:38cuando los errores no residen claramente en un solo lugar.
- 10:40Tomemos un escenario común de ASO.
- 10:42Creaste una nueva aplicación de funciones, pero una vez desplegada,
- 10:44el disparador decola falla porque el enlace no coincide con la firma del método.
- 10:49Normalmente, revisas registros, descubres que el enlace está mal,
- 10:51ajustas el JSON de la función manualmente,
- 10:53tal vez incluso alteras tu plantilla de infraestructuras
- 10:55y un valor tampoco coincide ahí.
- 10:58Cada paso es una búsqueda separada y cada corrección activa otra ejecución de prueba.
- 11:02Con el modo agente, el flujo de trabajo es diferente.
- 11:04Puede proponer el cambio de código,
- 11:05generar el enlace JSON de función correcto
- 11:07y mostrar ediciones para scripts de despliegue si no están alineados.
- 11:11Revisas, confirmas y avanzas sin pasar horas uniendo cada capa y acrofícola.
- 11:15Nadie debería sentir que se están realizando ediciones invisibles en segundo plan.
- 11:19Por eso el flujo de revisión es importante.
- 11:20En esta demostración lo recorremos juntos.
- 11:22El agente sugiere los cambios coordinados.
- 11:24Abriremos el DIF para inspeccionar exactamente lo que generó,
- 11:27ejecutar nuestras pruebas unitarias,
- 11:28validar la compilación localmente
- 11:29y solo entonces elegir si aceptamos o rechazamos los cambios.
- 11:33Ese ciclo de validación te mantiene en pleno control
- 11:35mientras elimina el trabajo pesado.
- 11:37Vale la pena recalcar que los agentes pueden ayudar a avanzar más rápido,
- 11:40pero no reemplazan las buenas pruebas de ingeniería.
- 11:42Debes seguir tratando las revisiones de código de integración continuada
- 11:44así como guardián en no negocio.
- 11:45Deja que la guía reduzca el tiempo que pasas en tareas de detective,
- 11:48pero mantén las verificaciones automáticas y la revisión humana como red de seguridad.
- 11:51Ese equilibrio resuelve el problema de confianza
- 11:53y asegura que la ganancia de velocidad no comprometa la estabilidad.
- 11:56La diferencia de velocidad no es teórica.
- 11:58Donde la búsqueda de errores y los parches manuales pueden consumir mediodía,
- 12:00las sugerencias coordinadas pueden reducirlo a minutos.
- 12:03Y el tiempo recuperado fluye de regreso al trabajo en el que realmente quieres invertir tu energía.
- 12:07Las funciones que notan tus usuarios y las decisiones de arquitectura que mejoran tu base de código.
- 12:11En lugar de apagar fuegos durante la ejecución, puedes diseñar con confianza desde el principio.
- 12:15Así que el ciclo de depuración ya no tiene por qué definir tu día.
- 12:18Con un agente que sugiere actualizaciones entre archivos,
- 12:20pasas de una búsqueda dispersa a un ritmo de revisar y aprobar,
- 12:23dejas de dar vueltas en círculos a través de los errores
- 12:25y comienzas a tratar la depuración como un paso estructurado,
- 12:28casi automatizado, casi automatizado en tu flujo de trabajo.
- 12:30Ese cambio libera espacio cognitivo y horas en el calendario para crear funciones,
- 12:33no solo para corregir fallas.
- 12:34Y una vez que corregir errores deja de tratarse de perseguir síntomas,
- 12:37se abre la puerta a algo más grande.
- 12:39¿Cómo podrías iniciar funciones completas de la misma manera estructurada?
- 12:42Imagina si el mismo flujo de trabajo que propone correcciones coordinadas
- 12:45pudiera también tomar una especificación en lenguaje sencillo
- 12:48y dar forma a una estructura funcional en torno a ella.
- 12:50Ahí es donde comienza la siguiente etapa del desarrollo.
- 12:53Desarrollo basado en especificaciones y en la sobrecarga misma.
- 12:56Uno de los cambios más interesantes ocurre cuando dejas de pensar
- 12:58solo en términos de archivos y métodos
- 13:00y comienzas a plantear el trabajo en lenguaje sencillo.
- 13:03Ahí es donde entra el desarrollo basado en especificaciones y en la sobrecarga misma.
- 13:05Imagina redactar una solicitud de función sencilla.
- 13:08Añade un flujo de trabajo de informes que genere resúmenes mensuales,
- 13:11los almacene y los haga disponibles a través de una página de administración.
- 13:14En lugar de obtener solo unos pocos fragmentos aislados,
- 13:16obtienes una estructura funcional ya mapeada a través de tu aplicación.
- 13:20Controladores preparados, modelos creados, servicios registrados y configuración conectada.
- 13:24Ese paso de describir la intención a ver aparecer un andamiaje concreto en tu proyecto
- 13:28es donde este enfoque finalmente se siente práctico en lugar de teórico.
- 13:31En configuraciones tradicionales, el desarrollo basado en especificaciones tiene una reputación pesada.
- 13:35En grandes organizaciones, generalmente significa largos documentos de requisitos,
- 13:39hojas de diseño de varias páginas y diagramas rígidos que retrasan a todos.
- 13:42Tienen sentido en industrias reguladas o equipos distintos globalmente,
- 13:44pero para la programación diaria, la mayoría de los desarrolladores los omiten.
- 13:47Escribir y mantener especificaciones detalladas añada un costo para que nadie tiene paciencia ni tiempo.
- 13:52Es trabajo extra acumulado sobre la entrega de funciones y a medida que se acercan los plazos,
- 13:56esos ciclos adicionales suelen sacrificarse.
- 13:58La ironía es clara, a los desarrolladores en realidad les gusta pensar en términos generales.
- 14:01Conocer la estructura de antemano es tranquilizador.
- 14:04El problema no es la intención, sino el mantenimiento.
- 14:06Una vez que la especificación empieza a perder sincronización con la realidad,
- 14:09el mantenimiento se vuelve una carga.
- 14:10Por eso, gran parte del trabajo real deriva hacia la improvisación en lugar del diseño completo,
- 14:14incluso en empresas que técnicamente respaldan una planificación exhaustiva.
- 14:18Un flujo de trabajo con agentes ofrece un alternativo.
- 14:19En lugar de exigir un documento de diseño pulido,
- 14:22puede ser un pulido,
- 14:22puede dar a traducir una especificación en lenguaje sencillo a una base de refinar.
- 14:26No necesitas diagramas, UML, ni mapas de interfaz escritos a mano.
- 14:29Simplemente puedes decir,
- 14:30crea un módulo de informes con un nuevo endpoint de API,
- 14:33vincularlo al almacenamiento y asegurarlo con acceso basado en roles.
- 14:36Y el sistema genera una base en los archivos de tu solución .net.
- 14:40En la demostración, leeré una especificación en lenguaje sencillo.
- 14:43En voz alta, mostraré los archivos que produjo el agente,
- 14:46controladores, modelos y registro de servicios.
- 14:47Y señalaré los puntos que aún necesitaba un refinamiento manual.
- 14:51De esa manera, puedes juzgar la calidad por ti mismo.
- 14:53Esto establece un punto medio entre dos modos de desarrollo.
- 14:56Por un lado está la programación intuitiva, rápida, libre, pero frágil, pero frágil para sistemas de labor.
- 15:01Por el otro lado está el diseño basado en especificaciones.
- 15:03Fiable, pero dolorosamente lento.
- 15:06Con el apoyo de un agente, describes la idea con palabras naturales,
- 15:08aparece la estructura base,
- 15:09y puedes iterar casi tan rápido como con la programación intuitiva,
- 15:12manteniendo el beneficio de una estructura organizada.
- 15:14Tomemos de nuevo ese flujo de trabajo de informe.
- 15:16Normalmente tendrías que crearlo, el modelo, construir el servicio de datos,
- 15:19conectar el controlador, configurar la seguridad y vincular todo en el inicio.
- 15:23Esto significa saltar entre múltiples archivos esperando que la consistencia se mantenga.
- 15:27Con este enfoque, la estructura base se coloca en su lugar de inmediato.
- 15:30El verdadero ahorro proviene menos de escribir menos líneas y más de evitar errores entre archivos,
- 15:34como olvidar registrar un nuevo servicio después de haberlo construido.
- 15:36Por supuesto, siempre está la cuestión del estilo.
- 15:39Forzar a la IA un código repetitivo o ignorar a las convenciones.
- 15:41En la práctica, los agentes a menudo reflejan los patrones de proyectos existentes en sus sugerencias.
- 15:46En la demostración verás ambas caras.
- 15:48Lugares donde coincidió perfectamente con la estructura de controlador de nuestro equipo
- 15:51y lugares donde sus suposiciones se desviaron.
- 15:54Esa mecha es importante.
- 15:55Sabrás en qué puedes confiar y qué necesitas ajustar todavía.
- 15:58El resultado final no es código estandarizado.
- 16:00Sigues sintiéndose como tu proyecto, solo que con menos trabajo manual de estructura.
- 16:04Mantienes la velocidad y sigues contando con una base que puedes perfeccionar para el crecimiento futuro,
- 16:08en lugar de que el trabajo de especificación se limite a arquitectos con paciencia para diagramas.
- 16:12Se convierte en una herramienta para cualquier desarrollador
- 16:14que quiera experimentar rápidamente sin sacrificar el orden.
- 16:18Y cuando esto se vuelve parte de tu flujo diario,
- 16:20la especificación deja de sentirse como un paso empresarial formal
- 16:22y más como una taquigrafía ligera, ligera.
- 16:25Tú describes tu intención, el sistema sienta las bases
- 16:27y tú te enfocas en dar forma a los detalles.
- 16:29El mayor impacto no proviene solo del código que generas,
- 16:32sino de lo que el ahorro de tiempo significa semana tras semana.
- 16:35Más horas para funciones, menos trabajo pesado en la configuración.
- 16:38Eso nos lleva directamente a la pregunta que más le importa a todo desarrollador.
- 16:41¿A qué equivalen realmente estos cambios en términos de productividad?
- 16:45La recompensa de la productividad.
- 16:47La verdadera pregunta no es si ahorras unos minutos aquí o allá,
- 16:49sino cómo esos pequeños cambios se acumulan en horas significativas a lo largo de una semana.
- 16:55Esta es la recompensa de la productividad.
- 16:56Recuperar tiempo que suele escaparse desapercibido a través del cambio de contexto,
- 16:59ciclos de compilación repetidos y parches manuales.
- 17:02La mayoría de los desarrolladores aceptan esas pequeñas pérdidas como parte del trauma.
- 17:0510 minutos aquí buscando un valor de configuración,
- 17:07otros 15 volviendo a ejecutar tras una referencia fallida
- 17:10o saltando entre archivos para verificar conexión.
- 17:12Por sí solos parecen insignificantes,
- 17:14pero sumados a lo largo de un sprint completo determinan cuánto valor real se entrega.
- 17:18Lo que parece movimiento rutinario esconde un lastre real en los tiempos de entrega.
- 17:22El peso oculto no está en los tiempos de compilación ni en la velocidad de escrito.
- 17:25Está en el ritmo de pausas impuesto tu concentración.
- 17:27Cada vez que pasas de un archivo a otro, tu cerebro se reinicia.
- 17:31Ese reinicia tiene un costo.
- 17:32Delegar correcciones repetitivas a un agente aligera esa carga.
- 17:36En lugar de reconstruir constantemente el contexto,
- 17:38dedicas tu enfoque donde importa resolviendo los problemas de diseño más grandes.
- 17:42Muchos equipos no rastrean estos microcostos porque no aparecen en los tickets de Jera
- 17:45ni en el historial de Git.
- 17:46Trabajo que no lleva a ninguna parte, no se registra, pero aún así consume energía.
- 17:49A medida que las bases de código escala en esta fricción no solo se suman de forma lineal,
- 17:53más capas significan más dependencias que mantener en memoria
- 17:56y más oportunidades de perder tiempo simplemente alineando la estructura antes de seguir avanzando.
- 18:00Los flujos de trabajo con agentes cambian la ecuación al atacar directamente estas pérdidas.
- 18:03No solo completan los métodos vacíos más rápido,
- 18:05reducen los bucles de búsqueda, parches y ejecuciones que se consumen las tardes.
- 18:09Los equipos que usan flujos de trabajo con agentes reportan tiempos de desbloqueo más cortos en muchos casos.
- 18:14En este video demostraremos una tarea de antes y después para que puedas juzgar el impacto.
- 18:18Registraré el tiempo que toma implementar la misma función de Azure manualmente
- 18:21y luego con el agente para que puedas ver la ganancia de productividad en términos concretos.
- 18:26Desde una perspectiva empresarial, el valor se refleja en la velocidad del proyecto.
- 18:29Los ciclos más rápidos no se tratan solo de la satisfacción del desarrollo.
- 18:32Determinan si las funciones se lanzan en esta versión o si se postergan varios trimestres.
- 18:35Influyen en la deuda técnica ya que menos parches y regresiones se acumulan en el backlog.
- 18:39Un flujo más fluido permite a los equipos avanzar con limpieza en lugar de retomar trabajo roto de sprints anteriores.
- 18:45Esa consistencia se traduce en menos situaciones de emergencia y una entrega más sólida con el tiempo.
- 18:48También existe el factor humano. Un día perdido persiguiendo errores deja a cualquier ingeniero agotado.
- 18:53Cuando hay fatiga, el diseño limpio se vuelve difícil, los detalles escapan y surgen errores.
- 18:58Al delegar los arreglos mecánicos a un agente, los desarrolladores se mantienen alertas por más tiempo.
- 19:02Ese enfoque adicional mejora tanto la productividad como la calidad.
- 19:06Cuando no te agotas por la fricción constante, eres libre de pensar de forma amplia y planificar mejor.
- 19:11La diferencia en la práctica se ve así.
- 19:12Una nueva función de Azure con múltiples enlaces e integraciones podría tomar dos días completos sin ayuda.
- 19:18Entre la configuración, las pruebas y corregir referencias incorrectas, la tarea se prolonga.
- 19:24Con la ayuda de un agente, la misma función puede estar lista en medio día.
- 19:27No porque se tomen atajos, sino porque la configuración entre archivos y la orquestación funcionan bien a la primera.
- 19:31El cronograma se reduce al eliminar comienzos falsos y esfuerzos redundantes.
- 19:36Algunos desarrolladores expresan una preocupación mágica.
- 19:38Confiar en una idea para mantenimiento debilita tus propias habilidades.
- 19:41Esa perspectiva suele pasar por alto lo que realmente está cambiando.
- 19:44Delegar la configuración repetitiva no debilita tu experiencia, sino que la preserva para el diseño y la arquitectura.
- 19:50En realidad, ganas espacio para practicar la resolución de problemas complejos en lugar de malgastar energía en correcciones.
- 19:55Si pruebas esto, comenta cuántas horas has recuperado en un sprint.
- 19:58Incluiré las respuestas interesantes en futuros videos.
- 20:00Saber cómo otros equipos experimentan este cambio da a todos una mejor idea del valor real, más allá de las demos.
- 20:07Una nota de precaución, automatización ayuda, pero la seguridad sigue siendo importante.
- 20:10Ejecuta siempre tus pruebas y usa la revisión de código para validar los cambios creados por la gente.
- 20:15Confía en que el trabajo pesado se reduce, pero mantén las mismas salvaguardas.
- 20:18La diferencia de velocidad solo vale la pena si la calidad se mantiene constante.
- 20:21Pruebas sólidas y una revisión inteligente de PR protegen tu canal de lanzamiento de una automatización frágil.
- 20:25El beneficio no es escribir líneas de código más rápido,
- 20:28sino liberar espacio para producir soluciones más sólidas, con menos fatiga y menos.