DOMINICODE

Tag: AI

  • Optimiza tu mentoring con IA: aprendizaje efectivo para desarrolladores

    Optimiza tu mentoring con IA: aprendizaje efectivo para desarrolladores

    ¿Quieres dejar de ser el cuello de botella y convertirte en el mentor que realmente forma gente?

    Tiempo estimado de lectura: 6 min

    • La IA es potente para preparar material pedagógico; el mentor sigue siendo responsable de validar y acompañar.
    • Usa prompts versionados, Katas con bugs intencionales y defensa oral para forzar pensamiento crítico.
    • Estructura el mentoring en cuatro capas: objetivo, material personalizado, ejercicio práctico y validación humana.
    Tabla de contenidos

    ¿Quieres dejar de ser el cuello de botella y convertirte en el mentor que realmente forma gente? Perfecto. Porque la IA te lo pone fácil —si sabes usarla— y también te lo deja todo más caro si lo haces mal.

    Poca gente habla de esto: la IA no va a sustituir a los docentes técnicos buenos. Los va a desnudar. Los malos quedarán expuestos. Los buenos escalarán su enseñanza como nunca. Descubrí algo curioso: con unos prompts bien pensados puedes preparar una lección que normalmente te llevaría horas, en 10 minutos. Y el desarrollador la absorbe mejor. Pero hay truco. No es darle la lección a la IA y olvidarte. Es usarla como motor pedagógico y seguir caminando junto al alumno.

    Resumen rápido (lectores con prisa)

    La IA funciona como herramienta de preparación pedagógica: genera explicaciones, ejercicios y ejemplos adaptados al stack. Úsala cuando necesites escalar material o crear Katas repetibles, pero siempre valida con interacción humana. La secuencia recomendada: define objetivo de aprendizaje, genera material personalizado, diseña ejercicio práctico y realiza validación 1:1. Versiona los prompts y obliga defensa oral y tests escritos para evitar atrofia del pensamiento crítico.

    Primero: qué hace bien la IA (y qué no)

    • Bien: diseña explicaciones, genera ejercicios adaptados al stack, crea ejemplos y casos de estudio, monta Katas con bugs intencionados.
    • Mal: reemplazar la empatía, entender la política interna de tu arquitectura, o garantizar que el talento del dev se forme por sí solo.
    • Resultado real: la IA es tu guionista. Tú sigues siendo el director.

    Regla de oro: la IA prepara. Tú validas. Tú acompañas.

    Cómo estructurar tu mentoring con IA (4 capas)

    1. Definir objetivo de aprendizaje (qué debe saber el dev al final).
    2. Generar material personalizado con IA (explicaciones + analogías + ejemplos).
    3. Diseñar ejercicio práctico y lab (Kata con bug).
    4. Validación humana: 1:1 donde el dev explica y demuestra.

    Si te saltas la validación, lo único que escalas es ilusión.

    Gancho pedagógico: analogías que conectan

    Un dev entiende más rápido con una buena metáfora. Pide a la IA analogías específicas y concretas, no genéricas.

    Prompt práctico

    “Actúa como Staff Engineer. Explica Angular Signals a un junior con ejemplos prácticos. Usa la analogía de una hoja de cálculo para contrastar Signals vs RxJS (BehaviorSubject). Muestra un ‘antes’ con RxJS y un ‘después’ con Signals, y finaliza con 2 casos donde Signals reduce re-rendering.”

    ¿Por qué funciona? Porque la hoja de cálculo es algo que todo el mundo visualiza. La analogía baja el umbral cognitivo y acelera la comprensión.

    Katas: el arma secreta para formar sin microgestionar

    Los Katas con errores intencionales enseñan mejor que 100 lecturas de docs. La IA puede generar ejercicios que replican problemas reales en tu stack.

    Prompt plantilla para Kata

    “Genera un componente React + TypeScript que simule un carrito. Introduce un bug sutil de ‘stale closure’ en useEffect y un problema de re-rendering. Devuélveme: 1) el código base, 2) 3 pistas progresivas, 3) 2 test-cases que deben fallar antes de arreglar.”

    Implementación práctica

    • Entrega el Kata al junior.
    • Pistas sólo si lo piden (no antes).
    • En la 1:1, pídele que explique por qué ese bug ocurre y que proponga dos soluciones.
    • Resultado: aprende a razonar, no a copiar.

    Enseñar arquitectura: casos de estudio progresivos

    No expliques CQRS con diagramas abstractos. Crea una historia que evolucione con la empresa.

    Prompt plantilla

    “Genera un caso de estudio: e-commerce monolítico que colapsa en Black Friday. Describe cómo extraer ‘Inventario’ a microservicio con Kafka. Explica beneficios, nuevas complejidades (consistencia eventual) y checklist de rollout.”

    Cómo usarlo:

    • Léele el caso al mid-level.
    • Pídele que proponga dos alternativas (monolito modular vs microservicio) con pros/cons.
    • Debate 15 minutos.
    • Tarea: diseñar contrato de API y tests de integración para el nuevo servicio.

    Evita la atrofia del pensamiento crítico

    Peor que no enseñar es permitir que el dev se apoye en Copilot/ChatGPT para resolver tu Kata. Entonces no aprendió nada. Tu métrica no es “funciona”, es “puedes explicarlo”.

    Reglas de control

    • Todo ejercicio debe terminar con defensa oral: el dev explica la solución en 1:1 y responde “¿qué pasa si…?” tres veces.
    • Obliga a escribir tests que prueben los casos límite que la IA no pensó.
    • Penaliza respuestas copiadas: si el dev no puede justificar, regresa el ejercicio.

    Plantillas de prompts listos para usar

    1) Explicación pedagógica (concepto nuevo)

    System: “Eres un Staff Engineer que sabe enseñar.”

    User: “Explícame [concepto] a un junior. Usa una analogía simple y un ejemplo mínimo en [stack]. Da 2 preguntas de comprobación y 1 mini-ejercicio.”

    2) Kata con bug intencional

    System: “Actúa como instructor de bootcamp.”

    User: “Crea un kata en [stack] que simule X problema. Incluye código con el bug, 3 pistas y 2 test cases que deben fallar.”

    3) Caso de estudio arquitectónico

    System: “Eres un arquitecto pragmático.”

    User: “Genera un caso de estudio: problema, soluciones posibles, trade-offs, checklist de rollout y métricas a vigilar.”

    Validación técnica: no confíes ciegamente

    La IA alucina. Especialmente con APIs nuevas. Siempre ejecuta y compila el ejemplo. Si vas a enseñar Angular Signals o Server Actions, valida primero.

    Checklist de pre-entrega

    • El código compila.
    • Los test-cases se ejecutan y fallan donde deben.
    • La analogía no distorsiona el concepto principal.
    • No hay promesas falsas sobre compatibilidad.

    Cómo convertir cada sesión en aprendizaje medible

    No dejes que la sesión sea nota mental. Traduce en artefactos.

    Después de cada 1:1 o Kata:

    • Crea un pequeño ticket con la tarea de seguimiento (1–2 subtareas).
    • Define métricas simples: tests añadidos, tiempo para arreglar, porcentaje de explicación correcta.
    • Revisa en 2 semanas. Si no hay progreso, cambia el enfoque de mentoring.

    Ejemplo concreto: “Explain Angular Signals”

    (Usa esto con tu junior)

    Prompt:

    “Actúa como Staff Engineer. Explica Angular Signals a un junior con ejemplos prácticos. Usa la analogía de una hoja de cálculo. Muestra cómo sería con RxJS y cómo mejora con Signals. Da 3 preguntas de comprobación y un mini-kata.”

    Entrega esperada del modelo:

    • Analogía clara.
    • Código ‘antes’ y ‘después’.
    • Tres preguntas que obligan al dev a pensar.
    • Un kata mini (5–10 líneas) para practicar.

    Lo que haces tú después:

    • Revisa la explicación.
    • Pide al dev que la replique sin mirar.
    • Si falla, repites el kata con otra analogía.

    Cultura: transforma la dependencia en competencia

    No se trata de prohibir la IA. Se trata de convertirla en herramienta de aprendizaje.

    Políticas que funcionan

    • Todo código asistido por IA viene con un párrafo: “¿Por qué esto resuelve el problema?” Si no existe, no se mergea.
    • Prompt registry en la wiki: guarda prompts usados para Katas y explicaciones. Auditoría futura.
    • Sesión semanal de 30 minutos: “Explain why this code sucks” — donde un dev explica por qué otra implementación es mala.

    Errores que vas a ver (y cómo evitarlos)

    • Error: el junior copia la solución y pasa el Kata. Solución: defensa oral + tests que el dev debe escribir.
    • Error: la IA mezcla versiones de API. Solución: siempre ejecutar y validar.
    • Error: confiar la formación solo a la IA. Solución: la IA prepara. Tú acompañas. Siempre.

    Cierre con acción (porque esto no acaba aquí)

    La IA te hace eficiente. Pero el talento se forma caminando juntos. Si quieres que te facilite el trabajo, tengo un kit listo: 10 prompts versionados para explicar conceptos, 5 Katas adaptadas a React/Node/Angular y una plantilla de 1:1 que fuerza la defensa técnica.

    Di “QUIERO EL KIT” y te lo envío en 10 minutos. O pega aquí el concepto que tienes que explicar mañana y te preparo la sesión con analogía, código y Kata listo para usar.

    No lo dejes en “algún día”. Si sigues esperando, tu equipo seguirá copiando soluciones que no entiende. Y entonces sí: la IA habrá acelerado la mediocridad. ¿Qué prefieres construir: gente que copia o gente que piensa? Yo sé la respuesta. ¿Tú?

    Dominicode Labs (mención)

    Si estás trabajando con automatización, agentes o workflows y buscas ejemplos prácticos y experimentos aplicados, puedes seguir explorando recursos y experimentos en Dominicode Labs. Es una continuación lógica para equipos que quieren sistematizar prompts, Katas y pipelines de validación técnica.

    FAQ

    ¿La IA puede sustituir al mentor técnico?

    No. La IA prepara material y escala explicaciones, pero no reemplaza la validación humana, la empatía ni la comprensión de la política interna de una arquitectura. El mentor sigue siendo responsable de acompañar y evaluar.

    ¿Qué es un Kata con bug intencional y por qué funciona?

    Es un ejercicio con un fallo deliberado que reproduce un problema real del stack. Funciona porque obliga al dev a razonar sobre causa-efecto, escribir tests y defender la solución en una 1:1, en lugar de copiar una solución aparentemente “correcta”.

    ¿Cómo evito que los devs copien la solución de la IA?

    Reglas: defensa oral obligatoria, escribir tests que cubran casos límite y penalizar soluciones sin explicación. Las pistas del Kata deben entregarse sólo bajo demanda.

    ¿Con qué frecuencia debo versionar mis prompts?

    Versiona cuando el kata funcione mejor o cuando la explicación suene rara. No hay un ritmo fijo: versiona según resultados y feedback del alumno.

    ¿Qué incluye la checklist de pre-entrega?

    Los ítems clave: el código compila, los tests fallan donde deben, la analogía no distorsiona el concepto y no hay promesas falsas sobre compatibilidad.

    ¿Qué métricas simples puedo usar para medir progreso?

    Ejemplos prácticos: tests añadidos, tiempo para arreglar, porcentaje de explicación correcta en la defensa oral y seguimiento en 2 semanas.

  • Optimiza tu flujo de trabajo en Angular con Copilot y Cursor

    Optimiza tu flujo de trabajo en Angular con Copilot y Cursor

    ¿Quieres que tu equipo deje de pelear con boilerplate y empiece a diseñar producto? Bien. Esto va de eso: Copilot para Angular —pero con criterio— usando Cursor o v0 para acelerar sin autodestruir la arquitectura.

    Tiempo estimado de lectura: 6 min

    Ideas clave

    • IA acelera pero no sustituye la decisión técnica: reduce boilerplate, pero aumenta la necesidad de revisar arquitectura.
    • Combina herramientas: v0 para UI, Cursor para integración contextual y Copilot para completados rápidos.
    • Implanta reglas y prompts: un archivo .cursorrules obliga convenciones modernas (Angular 17+, Standalone, Signals).
    • Proceso humano obligatorio: PRs generados por IA necesitan revisión, tests adversarios y auditoría.

    Poca gente lo dice así: las herramientas de IA no vienen a reemplazar programadores. Vienen a cambiar qué tipo de trabajo hacemos. Antes te peleabas con imports y TestBed; ahora peleas por decisiones arquitectónicas. Eso no es menos trabajo. Es trabajo de más valor. Y si no lo gestionas, la IA te regala código rápido… y deuda técnica a la misma velocidad.

    Resumen rápido (lectores con prisa)

    IA para desarrollo: genera boilerplate y UI rápido. Úsala para ahorrar tiempo en markup y tests repetitivos, pero exige reglas de proyecto (Angular 17+, Standalone, Signals), revisión humana y prompts versionados. Combina v0 para UI, Cursor para integración contextual y Copilot para completados.

    Primero: la promesa y el peligro, en dos líneas

    • Promesa: generar componentes, servicios y tests en segundos. Menos tiempo en boilerplate, más tiempo en lógica.
    • Peligro: aceptar el output sin auditarlo. La IA copia patrones viejos. Te regala “Angular 12” en 2026 si no le pones reglas.

    Por qué Angular es el mejor campo de juego para Copilot/Cursor

    Angular es verboso. Tiene DI, módulos, lifecycles y muchas opciones correctas. Esa verbosidad es precisamente la palanca: una IA bien dirigida elimina ruido repetitivo. Pero ojo: la IA no entiende tu contrato de negocio. Tú sí. Tu trabajo pasa de “escribir” a “auditar y decidir”.

    Herramientas y cuándo usarlas (sin romantizar)

    v0 (Vercel)

    genial para prototipos visuales. Saca HTML y clases Tailwind rápido. Úsalo para wireframes y para acelerar markup. No le pidas estado ni efectos.

    Cursor

    el copiloto contextual. Lee tu repo, entiende servicios existentes y genera pruebas y refactors con sentido. Aquí es donde pides migraciones a Signals o refactors RxJS → Signals.

    GitHub Copilot

    útil para completar bloques. No te fíes para refactors completos.

    Pauta: combina

    v0 para UI, Cursor para integrar y Copilot para atajos. Uno más: exige al modelo un estilo de proyecto (Angular 17+, Standalone, Signals). Si no lo pides, no lo obtendrás.

    Patrón de trabajo ideal (workflow)

    1. Idea rápida: pide a v0 un HTML/Tailwind para el UI.
    2. Traducción: pega ese HTML en Cursor y pide “Crea componente Standalone de Angular, usa Signals, inject()”.
    3. Integración: pide a Cursor que conecte el componente al servicio existente (o que genere el servicio tipado).
    4. Testing: pide a Cursor que cree TestBed y mocks. Revisa assertions.
    5. Revisión humana: valida arquitectura, performance y seguridad. Siempre humano.

    Prompting: si no controlas, te entregan legado

    La calidad del resultado depende del prompt. No es magia: las reglas importan. Debes forzar APIs modernas y convenciones de equipo. Crea un archivo de reglas para tu IDE, que el modelo verá como “estándar del proyecto”.

    Plantilla mínima de reglas (.cursorrules)

    No es opcional. Es tu contrato con la IA.

    // .cursorrules
AngularVersion: 17+
Components: Standalone true
State: Prefer Signals (signal, computed, effect)
DI: Use inject() where possible
Templates: Use @if/@for syntax for control flow
Testing: Generate Jest or Karma with explicit mocks, no shallow copy
RxJS: Use only when necessary; prefer Signals for UI derivations
Style: Strict typing, avoid any, include interfaces for API responses

    Usos concretos y prompts que funcionan (ejemplos prácticos)

    Convertir BehaviorSubject a Signals

    Prompt: “Refactoriza este servicio que usa BehaviorSubject para usar signal() y computed(). Mantén la API pública idéntica y añade tests que verifiquen que las suscripciones actúan igual.”

    Crear TestBed con spies

    Prompt: “Genera un TestBed para MyComponent. Mockea ApiService y AuthService con jasmine.createSpyObj. Crea tests para: carga inicial, error de API, y validación de formulario.”

    Generar componente desde HTML (v0 → Cursor)

    Flujo: Pide a v0 el HTML. Luego: “Convierte el HTML en MyWidgetComponent standalone con Inputs: title:string, data: any[]; usa Tailwind classes y Signals para estado local.”

    Testing: la IA acelera, pero no delegues la verificación

    Esto es serio: la IA crea tests de forma automática. Eso es bueno. Pero hay trampa: la IA escribe assertions que validan lo que ella generó. Si ella asumió un comportamiento erróneo, tus tests pasarán en verde. Por eso:

    • Revisa cada expect: ¿está validando la regla de negocio o solo el output esperado?
    • Genera tests adversarios: pídele a la IA que escriba “tests rotos” que simulen edge cases.
    • Introduce revisión humana obligatoria en PRs para tests generados por IA.

    Refactorizaciones a gran escala: estrategia segura

    Si vas a migrar una base entera a Signals o a Standalone components, hazlo por fases:

    1. Identifica módulos críticos.
    2. Refactoriza servicios primero (asegura contratos).
    3. Refactoriza componentes sendero a sendero (uno o dos features por PR).
    4. Usa tests generados por IA + validación manual.
    5. Monitor de runtime: telemetría para detectar regresiones.

    Ejemplo de prompt para migración a Signals (listo para pegar)

    “Refactoriza el archivo user.service.ts para reemplazar BehaviorSubject con signal(). Mantén la API externa (getUser, updateUser) sin cambios. Añade computed properties para isLoggedIn y profileSummary. Escribe tests unitarios que verifiquen comportamiento de suscripciones y actualización de estado.”

    Código ejemplo: TestBed generado por IA (y qué revisar)

    La IA suele producir este bloque. Úsalo pero revisa nombres y assertions.

    beforeEach(async () => {
  const apiSpy = jasmine.createSpyObj('ApiService', ['getData', 'update']);
  await TestBed.configureTestingModule({
    imports: [MyStandaloneComponent],
    providers: [{ provide: ApiService, useValue: apiSpy }]
  }).compileComponents();
});

    Revisar:

    • ¿Se mockea todo lo necesario? (Router, HttpClient, etc.)
    • ¿Los spies devuelven observables cuando se espera observables?
    • ¿Los tests usan fakeAsync/tick cuando interactúan con timers o zonas?

    Costes, velocidad y gobernanza

    • Rentabilidad: la IA reduce horas humanas pero aumenta la necesidad de revisiones. Calcula ROI: horas ahorradas vs tiempo de code review extra.
    • Versionado: trata los prompts como código. Guarda versiones de prompts y .cursorrules.
    • Auditoría: obliga a generar un changelog de cada PR producido con IA: qué partes generó la IA y qué partes editó un humano.

    Antipatrones que veo (y que debes bloquear)

    • Merge automático de PRs con tests generados por IA sin revisión.
    • Usar Copilot para “arreglar” errores de producción; terminarás con soluciones temporales eternas.
    • Pedir a la IA que “optimice rendimiento” sin métricas. La IA sugiere microoptimizations; pide pruebas de mejora antes de aceptar.

    Estrategias para equipos (roles y responsabilidades)

    • Senior devs: definir .cursorrules, revisar PRs críticos, decidir migraciones a Signals.
    • Mid devs: usar tools para producir código, ejecutar tests, proponer mejoras.
    • Juniors: enfocarse en pruebas, documentación y tareas guiadas. La IA es su acelerador, no su profesor único.

    Métrica que importa realmente

    No midas líneas generadas. Mide:

    • Tiempo de entrega de features reales.
    • Reversiones/regresiones post-PR IA.
    • Cobertura de código útil (tests que validan la lógica).
    • Deuda técnica introducida por PRs IA (contada en horas de revisión).

    Cultura: sin ella, la IA es peligro

    La IA potencia malos hábitos si tu equipo no cambia procesos. Establece:

    • PR review obligatorio para código generado por IA.
    • Etiquetas en PRs: “generated-by-IA”.
    • Sesiones regulares para ajustar prompts y .cursorrules.

    Ejemplo de checklist mínimo para PR con IA

    • [ ] ¿Se aplicaron rules (Angular 17, Standalone, Signals)?
    • [ ] ¿Se generaron tests? ¿Validan reglas de negocio?
    • [ ] ¿Hay mocks correctos y casos edge?
    • [ ] ¿Se ejecutó E2E en staging?
    • [ ] ¿Se documentaron cambios en prompts?

    Cierre: lo que debes hacer hoy mismo

    No esperes a que el resto del equipo “se adapte”. Empieza con estas tres acciones:

    1. Crea .cursorrules en la raíz del repo. Hazla obligatoria.
    2. Configura un endpoint interno para almacenar prompts aprobados y su versionado.
    3. En la próxima PR que use IA, reserva 30 minutos para auditar tests y arquitectura. Si tu equipo lo hace una vez, lo hará siempre.

    ¿Quieres que te haga las reglas para tu repo (Angular 17, Signals, Jest, Tailwind)? Respóndeme “Quiero las reglas” y te devuelvo un .cursorrules y 10 prompts listos para usar: componentes, servicios, migraciones y tests. No es magia. Es disciplina con atajos inteligentes. ¿Lo quieres ahora?

    Dominicode Labs

    Si tu flujo incluye automatización, agentes o workflows relacionados con IA, considera documentar y versionar prompts y reglas como parte de la gobernanza. Para más recursos y ejemplos prácticos sobre process-driven prompts y gobernanza de IA técnica, visita Dominicode Labs.

    FAQ

    ¿La IA reemplazará a los desarrolladores?

    No. La IA cambia el tipo de trabajo: menos esfuerzo repetitivo y más decisiones arquitectónicas y de negocio. Necesita supervisión humana constante.

    ¿Cuál es la combinación ideal de herramientas?

    v0 para UI y prototipos, Cursor para refactors e integración contextual, y Copilot para completados. Usa cada herramienta para su fortaleza y exige reglas de proyecto.

    ¿Qué debe contener .cursorrules?

    Reglas de versión de Angular, convención de componentes (Standalone), preferencia por Signals, DI con inject(), control de templates, testing estricto y estilo tipado. El archivo de ejemplo está en el artículo.

    ¿Cómo evito que la IA introduzca deuda técnica?

    Imponiendo reglas, revisiones humanas, versionado de prompts, PRs por fases y telemetría en runtime para detectar regresiones.

    ¿Los tests generados por IA son fiables?

    Pueden ser útiles, pero la IA a menudo valida su propio output. Revisa asserts, añade casos adversarios y obliga revisión humana.

    ¿Qué proceso de revisión recomiendas para PRs generados por IA?

    Revisión obligatoria por un senior, checklist que verifique reglas del proyecto, ejecución de E2E en staging y documentación de qué generó la IA y qué editó un humano.

  • Cómo usar IA en Angular correctamente y evitar la deuda técnica

    Cómo usar IA en Angular correctamente y evitar la deuda técnica

    ¿Sabes qué es peor que no usar IA en Angular? Usarla mal y creer que todo está bien.

    Tiempo estimado de lectura: 6 min

    • La IA no es neutral: los modelos tienden a reproducir código antiguo y antipatrón, lo que genera deuda técnica.
    • Exige reglas y prompts versionados: pide arquitectura y restricciones, no solo “haz un componente”.
    • Revisa PRs IA-assisted rigurosamente: checklist, métricas y explicación humana obligatoria.

    Introducción

    Poca gente lo dice en voz alta: la IA no es neutral. Los modelos devuelven lo más probable según lo que han visto… y lo que han visto es código antiguo, tutoriales desactualizados y montones de antipatrón. Resultado: miles de PRs que “funcionan” pero son bombas de deuda técnica con temporizador. Y tú, con suerte, te enteras cuando el bundle explota en producción.

    Esto no es una bronca moral. Es una advertencia práctica.

    La mayoría de desarrolladores Angular usan mal la IA (y ni siquiera lo saben). Lo hacen porque la IA les da lo que piden y ellos no piden con criterio. Piden “haz un componente” y reciben una reliquia: NgModules, BehaviorSubjects por todos lados, .subscribe() sin limpieza y cero Signals. Compilan. Rompen en escala.

    Si eres Tech Lead, Senior o simplemente alguien que no quiere que su app sea un Frankenstein, esto es para ti. Voy a darte lo que nadie te dice en conferencias polidas: cómo usar la IA con Angular sin meter la pata, prompts que funcionan y políticas que evitan que el repo se convierta en un cementerio de buenas intenciones.

    Resumen rápido (lectores con prisa)

    La IA no es neutral: los modelos devuelven las soluciones más probables según su entrenamiento.

    Mucho del código base de entrenamiento corresponde a Angular antiguas (8–12), antes de Standalone Components y Signals.

    Pide arquitectura y restricciones (prompts versionados); exige explicación humana y tests para cualquier PR asistido por IA.

    Mide PRs IA-assisted por rework, MTTR y memory leaks; si suben, la IA está degradando tu producto.

    Primero: lo que realmente está pasando

    La IA aprende de repositorios públicos. Mucho del código que alimenta estos modelos fue escrito para Angular 8–12.

    Angular cambió. Standalone Components, Signals, Control Flow y takeUntilDestroyed son la nueva guardia.

    Los LLMs siguen escribiendo código vintage. Te lo sirven envuelto y listo para mergear.

    No es culpa del modelo. Es culpa de quien no lo contextualiza.

    La diferencia entre “funciona” y “es mantenible”

    La diferencia entre “funciona” y “es mantenible” son decisiones que la IA no puede tomar por sí sola. Tú sí puedes.

    Tres antipatrones que detectas rápido (y que matan tu app lentamente)

    1) Reactividad híbrida

    Un PR mezcla BehaviorSubjects con Signals y subscribes por doquier. Resultado: re-renders inesperados, condiciones de carrera y debugging por mensajes de stack largos. Si lo ves, pide explicaciones claras: ¿por qué RxJS aquí y no Signals?

    2) Suscripciones huérfanas

    Código que usa .subscribe() sin takeUntilDestroyed o sin unsubscribe. Esto es memoria que se queda. A escala, tu cliente nota latencia y tú notas llamadas perdidas.

    3) Módulos por costumbre

    Componente “autónomo” que igual requiere NgModule. El bundle crece. El tree-shaking muere. La app se pone lenta en móviles. Y nadie recuerda por qué se introdujo ese módulo en primer lugar.

    Cómo arreglarlo sin convertirte en un nazi del código

    No se trata de prohibir la IA. Se trata de exigirle reglas de juego. Y versionarlas como si fueran tests.

    Regla 1: No pidas código. Pide arquitectura.

    Los prompts vagos generan código vagabundo. Los prompts específicos crean artefactos fiables.

    Prompt base (cópialo y adáptalo):

    “Eres un Staff Engineer especialista en Angular 17+. Refactoriza/crea [componente|servicio|PR] con estas restricciones: 1) Usa Standalone Components. 2) Aplica Signals para el estado local (signal/computed). 3) Limita RxJS exclusivamente a llamadas HTTP con operadores modernos. 4) Usa inject() en lugar de constructor(). 5) Incluye takeUntilDestroyed donde haya subscripciones. Devuélveme: 1) código, 2) tests que cubran casos límite, 3) checklist de riesgos y métricas a vigilar tras deploy.”

    ¿Ves la diferencia? No “haz un componente”, sino “hazlo según las reglas modernas y explícitas”.

    Regla 2: La IA es tu linter arquitectónico, no tu desarrollador

    No le pegues un ticket grande a la IA y mergees. Haz que la IA haga refactors y análisis. Pega un componente legacy y pídele migrarlo a Signals y Standalone. Pídele también un diff de riesgos.

    Prompt para migración:

    “Refactoriza este componente legacy (pego archivo). Reemplaza Observables derivados por computed() Signals. Asegura el mismo comportamiento. Indica: 1) supuestos que cambian, 2) pruebas adicionales necesarias, 3) riesgos operativos.”

    Regla 3: Versiona prompts y publícalos en la wiki del equipo

    Trátalos como infra. Cambia versión cuando el prompt mejore. Si algo rompe, tendrás historial para auditar: qué prompt produjo qué cambio.

    Regla 4: Exige una “explicación humana” en cada PR generado o asistido por IA

    Si tu app se rompe, quieres saber quién decidió. No aceptes merges sin:

    • Un párrafo (2–4 líneas) que explique por qué la elección es correcta;
    • Una lista de escenarios que prueban la decisión;
    • Al menos 1 prueba que falla si la suposición es falsa.

    Checklist rápido para revisar PRs (lo lees en 60 segundos)

    • ¿Usa Standalone Components? Si no, ¿por qué?
    • ¿State local con Signals o BehaviorSubjects? Preferir Signals salvo justificación.
    • ¿Suscripciones con takeUntilDestroyed o patrón seguro?
    • ¿Se agregaron tests para edge cases concurrentes?
    • ¿Dependencias nuevas justificadas por RFC?
    • ¿Quién será responsable del mantenimiento?

    Prompts listos para usar (copiar y pegar)

    1. Auditor de PR

      System: “Actúa como Senior Angular Architect.”
      User: “Analiza este diff y responde: 1) tres supuestos operativos que hace, 2) tres formas en que falla a escala y cómo detectarlo, 3) recomendación (aceptar/modificar/rechazar) con pasos concretos.”

    2. Generador de Kata (para mentoring)

      System: “Actúa como instructor.”
      User: “Crea un kata en Angular con Signals que contenga un bug sutil de reactividad. Incluye 1) código base, 2) 3 pistas, 3) tests que inicialmente fallan.”

    3. Migrador a Signals

      System: “Actúa como Staff Engineer pragmático.”
      User: “Refactoriza este componente a Signals. Mantén el comportamiento funcional. Proporciona diff, pruebas y checklist de rollback.”

    Métricas que importan (no las obvias)

    Olvida commits por día. Mide lo que realmente previene incendios.

    • % de PRs etiquetados “IA-assisted” que requieren rework por problemas arquitectónicos.
    • Tiempo medio hasta rollback (MTTR) tras deploys con cambios IA-assisted.
    • Número de memory leaks detectados por semana en staging.
    • Tamaño del bundle inicial tras merges (trend line).

    Si esas métricas suben, tu IA está haciendo algo peor que inútil: está degradando tu producto.

    Cultura y políticas (si no las pones, nadie las seguirá)

    • Política “IA-assisted” obligatoria: todo PR generado/ayudado por IA debe llevar etiqueta y la explicación humana.
    • Prompt Registry: versionado de prompts y ejemplos aprobados por el equipo.
    • Pistas obligatorias: Katas que sirvan para evaluar si alguien sabe explicar lo que la IA generó. Si no puede explicarlo, vuelta atrás.
    • Guardrails de dependencia: librerías nuevas requieren aprobación de Tech Lead y Security.

    Errores reales que verás (y cómo atajarlos)

    Error: “Funciona en local, perfecto”.

    Realidad: pasó tests, pero explotó en mirror de tráfico. Solución: siempre despliegue con feature flags y monitorización explícita (p95, error budget).

    Error: “El junior lo puso en prod con Copilot”.

    Realidad: nadie entendía la implementación. Solución: defensa técnica obligatoria. Si quien mergea no lo puede explicar, revert.

    Error: “Prompts mágicos de StackOverflow”.

    Realidad: la IA copia snippets inseguros. Solución: validación de seguridad automática y revisión manual.

    Metáfora que te pega: la excavadora y el plano

    Piensa en la IA como una excavadora gigante. Mueve toneladas en minutos. Sin plano, destruye cimientos. El Tech Lead es el que marca dónde cavar, qué pilares dejar intactos y cómo rellenar después. Usar la excavadora sin plano es rapidez sin criterio. Y eso se paga caro.

    Último truco: la regla de las tres preguntas

    Antes de aceptar un PR asistido por IA, pregúntate:

    • ¿Qué suposición técnica hace esta implementación?
    • ¿Qué falla si esa suposición es falsa?
    • ¿Cómo lo detecto y qué hago en 15 minutos si falla?

    Si no puedes responder las tres, no lo merges.

    Cierre con acción (porque esto no acaba aquí)

    Si quieres dejar de encontrar sorpresas a medianoche, no hay excusas: necesitas prompts, plantillas y un kit de auditoría que funcione desde hoy.

    Di “QUIERO EL KIT” y te mando:

    • 10 prompts versionados (arquitectura, PR audit, migración a Signals, Katas).
    • Plantilla PR con checklist obligatorio.
    • Mini-RFC para tu política “IA-assisted”.
    • 5 tests de estrés para staging que puedes pegar en CI.

    Y si no quieres el kit, al menos copia esto en tu wiki y pásaselo al equipo. Pero no te quedes callado cuando el AI-generated pain llegue: será tarde.

    Esto no acaba aquí. Tu repo habla. ¿Vas a escucharlo o seguirás fingiendo que todo está bien?

    Dominicode Labs

    Si gestionas automatización, IA aplicada, agentes o workflows como parte de tu stack, puede interesarte explorar recursos y experimentos prácticos. Sigue esta continuación lógica: Dominicode Labs.

    FAQ

    ¿Por qué se dice que la IA no es neutral?

    Porque los modelos devuelven lo más probable según los datos con los que fueron entrenados. Si ese entrenamiento contiene código antiguo o antipatrón, los resultados reflejarán esas prácticas.

    ¿Qué son Standalone Components y por qué importan?

    Standalone Components son una característica moderna de Angular que permite declarar componentes sin NgModules, reduciendo el bundle y mejorando el tree-shaking. Importan porque evitan módulos innecesarios que aumentan el tamaño y la complejidad.

    ¿Cuándo debo preferir Signals sobre RxJS?

    Preferir Signals para estado local y recalculación reactiva simple; usar RxJS cuando se trabaja con flujos complejos o streams combinados, idealmente limitándolo a llamadas HTTP o casos donde sus operadores sean necesarios.

    ¿Qué debe incluir la explicación humana en un PR IA-assisted?

    Un párrafo de 2–4 líneas justificando la elección técnica, una lista de escenarios que prueban la decisión y al menos una prueba que falle si la suposición es falsa.

    ¿Qué métricas concretas debo añadir al dashboard?

    Por ejemplo: % de PRs IA-assisted que requieren rework por arquitectura, MTTR tras deploys IA-assisted, número de memory leaks detectados en staging y tamaño del bundle inicial por tendencias.

    ¿Cómo versiono prompts de forma práctica?

    Guarda cada prompt en un repositorio o wiki con una versión semántica, ejemplos de entrada/salida y notas de cambios. Trata los prompts como infraestructura: cambia la versión cuando el prompt cambie y registra qué cambios produjo.

  • Captura y procesamiento de audio en Angular usando Whisper

    Captura y procesamiento de audio en Angular usando Whisper

    ¿Por qué sigues pidiendo que el usuario haga clic cuando puede hablar y hacer todo en un par de segundos?

    Tiempo estimado de lectura: 6 min

    • Separación clara de responsabilidades: captura en cliente, transcripción en BFF, NLU en modelo, mutación en cliente.
    • No exponer keys: nunca llames a Whisper desde el cliente; pon la inteligencia detrás de un BFF con validación y rate-limits.
    • Diseño robusto de intent JSON: schema estricto (type, payload, confidence) y confirmación si confidence < 0.6.
    • UX y seguridad: indicadores de escucha, confirmación, undo y políticas de retención and RLS.
    • Observabilidad y pruebas: telemetría end-to-end, tests unitarios y e2e con fixtures de audio.

    Poca gente habla claro sobre esto: voz no es solo comodidad; es riesgo, latencia y caos semántico si no lo diseñas como corresponde. Aquí no vas a leer teoría aburrida. Te doy un patrón probado, código que funciona y las trampas que debes bloquear para no romper la UX, la seguridad ni tu facturación de OpenAI.

    Resumen rápido (lectores con prisa)

    Qué es: Un pipeline voz → BFF → Whisper → LLM que devuelve JSON de intención.

    Cuándo usarlo: Cuando quieras ejecutar acciones en la app desde voz manteniendo seguridad y auditabilidad.

    Por qué importa: Evita exponer keys, controla costes, garantiza validación y permite undo/confirm.

    Cómo funciona (alto nivel): Captura en cliente, sube al BFF, transcribe, parsea a JSON tipado, cliente aplica acción tras confirmación según confianza.

    Primero: por qué no debes llamar a Whisper desde el cliente

    Porque exponer claves en un bundle es regalarle el coche a cualquiera. ¿A quién le importa que te cueste dinero? A ti. Además, si el cliente hace retransmisiones directas, pierdes control: throttling, RLS, logging y sanitización. Pon la inteligencia en una capa intermedia. Punto.

    El pipeline ideal — teléfono a mesa de operaciones

    1. Captura

    MediaRecorder en el cliente. Corta en chunks razonables (≤60s).

    2. Upload seguro

    FormData + JWT al BFF. Validación y rate limiting ahí.

    3. Transcripción

    Whisper en BFF → texto literal.

    4. NLU

    Modelo rápido (p.ej. gpt-4o-mini) transforma texto en JSON estrictamente tipado.

    5. Envío al cliente

    JSON con “type” y “payload”.

    6. Mutación de estado

    NgRx dispatch o Elf repository update.

    7. UX

    Confirmación, undo, telemetry.

    Código que vas a usar (y revisar antes de darle al pasante)

    A continuación tres fragmentos mínimos. Cópialos, pégalos, pero audita nombres y errores. No aceptes un “funciona” sin pruebas.

    1) Capture + envío desde Angular (servicio)

    // voice.service.ts
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class VoiceService {
  private mediaRecorder?: MediaRecorder;
  private chunks: Blob[] = [];

  async startRecording(): Promise {
    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
    this.mediaRecorder = new MediaRecorder(stream);
    this.chunks = [];
    this.mediaRecorder.ondataavailable = (e) => this.chunks.push(e.data);
    this.mediaRecorder.start();
  }

  stopRecording(): Blob {
    if (!this.mediaRecorder) throw new Error('No recording in progress');
    this.mediaRecorder.stop();
    const blob = new Blob(this.chunks, { type: 'audio/webm' });
    this.mediaRecorder = undefined;
    return blob;
  }

  async sendToBff(blob: Blob, token: string) {
    const fd = new FormData();
    fd.append('audio', blob, 'voice.webm');

    const res = await fetch('/api/voice/process', {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${token}` },
      body: fd
    });

    if (!res.ok) throw new Error('Server error');
    return res.json(); // { type: '...', payload: {...} }
  }
}

    UX pattern: start→listen→stop→spinner→result y un “¿Era esto lo que querías?” con Undo.

    2) BFF (Node/Express) — Whisper + Intent Parsing (structured output)

    Este es el cerebro. Aquí validas usuario, tamaños, y llamas a Whisper y a tu LLM para parsear intención.

    // bff.js (esqueleto)
const express = require('express');
const fetch = require('node-fetch'); // o openai sdk
const multer = require('multer');
const upload = multer();
const app = express();

app.post('/api/voice/process', authenticateJWT, upload.single('audio'), async (req, res) => {
  try {
    const audioBuffer = req.file.buffer;

    // 1) Transcribe with Whisper
    const whisperResp = await callWhisperTranscription(audioBuffer);

    // 2) Parse intent with a model (structured output)
    const nluPayload = {
      prompt: `Transform the following user phrase into a strict JSON with fields: type, payload. Return only JSON.\n\nPhrase: ${whisperResp.text}`,
      max_tokens: 200
    };
    const parsed = await callNLUModel(nluPayload);

    // Validate structure server-side (type present, payload object)
    if (!parsed.type || typeof parsed.payload !== 'object') throw new Error('Invalid intent');

    // Optional: store audit log, attach userId, timestamp
    await auditLog(req.user.id, whisperResp.text, parsed);

    res.json(parsed);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Could not process audio' });
  }
});

    Notas: añade rate-limits, límites de audio (ej. 60s), y saneamiento del texto. Logea hashes, no textos sensibles salvo consentimiento.

    3) Mapeo a NgRx / Elf en Angular

    NgRx — dispatch desde un effect o servicio:

    // voice.handler.ts (usando NgRx)
import { Store } from '@ngrx/store';
import * as CalendarActions from '../store/calendar.actions';

constructor(private voiceSvc: VoiceService, private store: Store) {}

async handleVoiceFlow(token: string) {
  await this.voiceSvc.startRecording();
  // user stops...
  const blob = this.voiceSvc.stopRecording();
  const intent = await this.voiceSvc.sendToBff(blob, token);

  // Map server intent 'type' to action
  if (intent.type === '[Calendar] Add Meeting') {
    this.store.dispatch(CalendarActions.addMeeting({ meeting: intent.payload }));
  }
}

    Elf — actualización directa y más pragmática:

    // voice.handler.elf.ts
constructor(private voiceSvc: VoiceService, private calendarRepo: CalendarRepo) {}
async handleVoiceFlow(token: string) {
  const blob = this.voiceSvc.stopRecording();
  const intent = await this.voiceSvc.sendToBff(blob, token);
  if (intent.type === '[Calendar] Add Meeting') {
    this.calendarRepo.addMeeting(intent.payload);
  }
}

    Diseño del JSON (no negocies esto con Product)

    Define un schema y oblígalo en el BFF. Un ejemplo mínimo:

    {
  "type": string, // canonical action name
  "payload": object, // datos tipados
  "confidence": 0.0-1.0 // opcional
}

    Si confidence < 0.6, no ejecutes automáticamente: pide confirmación.

    UX: los detalles que evitan que te caguen a reviews

    • Indicador claro de escucha (ondas, micro rojo).
    • Feedback de “procesando…” tras detener.
    • Confirmación si confidence baja (<0.6): “¿Quieres añadir esto? [Editar] [Confirmar]”.
    • Undo visible por 10 segundos con animación.
    • Muestras de texto transcrito y opción de edición antes de ejecutar (para comandos complejos).
    • Fallo graceful: fail-open para acciones no críticas; fail-safe/confirmar para deletions o transferencias.

    Verificación y métricas que importan

    • Latencia total (client → BFF → model → client).
    • Tasa de aciertos (human-reviewed vs ejecutado automáticamente).
    • Falsos-positivos que produjeron acciones erróneas.
    • Cost per transcription + NLU.
    • Uso por usuario (rate limiting por userId).

    Edge cases y cómo los proteges

    • Ruido ambiental: pre-filter de audio RMS antes de subir.
    • Comandos parciales: chunking + reassembly en BFF.
    • Idiomas mezclados: detect language step, route to right model.
    • Datos sensibles: si hay PII, guarda solo hashes; pide consentimiento explícito.

    Seguridad y cumplimiento (lo básico que nadie quiere leer hasta que explota)

    • Nunca keys en frontend.
    • JWT check y RLS en BFF.
    • Minimiza retention: guarda audio solo si es necesario y con consentimiento.
    • En criptografía: almacena audios en S3 cifrado y borra tras X días si no hay auditoría.
    • GDPR: confirma base legal antes de usar voice as evidence.

    Operaciones: despliegue y costes

    Empieza con un plan que permita throttling. Modelos grandes cuestan; divide el pipeline: Whisper (ASR) + NLU ligero para intent parsing.

    Si necesitas baja latencia, usa regiones cercanas y cachea prompts y parsers. Monitoreo: traces end-to-end (OpenTelemetry). Si un usuario reporta “se añadió la reunión que no pedí”, necesitas reconstruir audio → transcript → intent.

    Testing: no dejes que el QA improvise

    • Tests unitarios del BFF: mocking de Whisper y del NLU.
    • Test e2e: fixtures de audio (simula blobs) que pasan por todo el pipeline.
    • Human-in-the-loop: usa un panel de revisión para los primeros 1k comandos y ajusta prompts.

    Prompts: cómo pedirle al LLM que devuelva JSON útil

    System prompt (ejemplo):

    Eres un normalizador de intenciones. Recibe: "transcription". Devuelve SOLO JSON con keys: type (string), payload (object), confidence (number 0-1). Normalize date/time to ISO8601. Si la intención no es reconocible, return type: "UNKNOWN" y payload: {}.

    Haz esto: versiona los prompts. Guarda historial. Cambia prompts con cuidado.

    Cierre con propósito — lo que tienes que hacer ahora

    No empieces a grabar voces sin este checklist:

    • BFF en su lugar (keys seguras + rate-limit).
    • Schema JSON aprobado.
    • UX: confirmación + undo.
    • Telemetry y panel de revisión humana.

    Si quieres, te lo doy listo: un repo de ejemplo con Angular service, BFF (Node), integraciones Whisper + NLU prompt, y tests e2e con audio fixtures. Responde “DAME EL REPO” y te lo paso: BFF, scripts de ci, prompts versionados y 10 casos de prueba humanos.

    Esto no acaba aquí. La voz cambia cómo la gente interactúa con tus productos. Si no lo haces bien, te mirarán raro. Si lo haces bien, tus usuarios te creerán telepático. ¿Quieres que empecemos por el BFF o por la UI? Responde “BFF” o “UI” y te doy el plan con código listo para copiar y pegar.

    Dominicode Labs

    Para quienes integran workflows, agentes y automatización con IA aplicado a productos, puede ser útil revisar recursos y experimentos de Dominicode Labs. Continúa la lectura y, si quieres ejemplos y repos completos, revisa Dominicode Labs.

    FAQ

    ¿Por qué no debo exponer mi key en el frontend?

    Porque exponer claves en un bundle permite que cualquiera las use. Pierdes control sobre costes, logging, rate-limits y seguridad. La solución es poner la lógica en un BFF que valide JWT, aplique RLS y haga sanitización.

    ¿Qué hago si la confianza (confidence) es baja?

    Si confidence < 0.6, no ejecutes automáticamente. Pide confirmación al usuario, ofrece editar el texto transcrito y muestra opciones claras: Editar, Confirmar, Cancelar.

    ¿Cómo limito el audio que suben los usuarios?

    Implementa límites en el cliente (chunking ≤60s) y valida tamaño en el BFF. Añade rate-limits por userId y chequeos de RMS para filtrar ruido antes de subir.

    ¿Qué métricas debo monitorizar inicialmente?

    Latencia end-to-end, tasa de aciertos comparada con revisión humana, falsos positivos, coste por transcripción+NLU y uso por usuario (rate limiting).

    ¿Cómo pruebo el pipeline en QA?

    Tests unitarios con mocks de Whisper y NLU, e2e con fixtures de audio (simula blobs) que pasen por todo el pipeline y un panel human-in-the-loop para las primeras muestras.

    ¿Qué hago con datos sensibles detectados en audio?

    Guarda solo hashes si es posible, pide consentimiento explícito para retención de audio y aplica políticas de borrado (ej. S3 cifrado y purge tras X días salvo auditoría).

  • Cómo un Tech Lead utiliza IA para decisiones técnicas efectivas

    Cómo un Tech Lead utiliza IA para decisiones técnicas efectivas

    ¿Sigues tomando decisiones técnicas a ciegas y esperando que el código te lo diga todo?

    Tiempo estimado de lectura: 7 min

    • IA como herramienta de decisión: la IA no reemplaza juicio; lo amplifica.
    • Reglas prácticas: contexto claro, supuestos explícitos y validación humana.
    • Acciones concretas: PR summaries, triage con n8n y PoC de arquitectura.

    Poca gente habla de esto: la IA no viene a escribir tu código perfecto. Viene a obligarte a pensar mejor. Descubrí algo curioso en los últimos equipos con los que trabajé: los Tech Leads que usan IA bien dejan de apagar incendios. Empiezan a diseñar el futuro con menos ruido y más criterio.

    Esto no es teoría. Es práctico. Y sí: directo, sin florituras. Voy a contarte cómo un Tech Lead puede usar IA para tomar mejores decisiones —no para ser reemplazado, sino para amplificar su cabeza—, con pasos concretos, ejemplos de prompts, riesgos reales y una mini hoja de ruta que puedes implementar esta semana.

    Resumen rápido (lectores con prisa)

    La IA sintetiza contexto, enumera trade-offs y acelera tareas repetitivas. Úsala para comparar opciones, automatizar triage y generar pruebas/documentación; siempre con supuestos claros y validación humana. Implementa PoC de resúmenes de PRs y triage en una semana y define una política de privacidad para lo que puede salir de tu repositorio.

    Por qué funciona la IA para decisiones técnicas

    Porque la IA sintetiza, conecta piezas y enumera trade-offs sin agenda. No reemplaza tu juicio. Lo estira. Es como un sparring: te devuelve lo que le das, pero más rápido, con memoria y sin excusas.

    Reglas que no negociarás

    • La IA recibe contexto concreto.
    • Las respuestas deben venir con supuestos claros.
    • Ninguna recomendación en producción sale sin validación humana.

    Tácticas concretas

    1) Evaluación de trade-offs en arquitectura — sin drama

    Las decisiones arquitectónicas son guerras de costo vs. riesgo vs. tiempo. La IA las hace manejables si le das reglas.

    Qué pedirle:

    • Simular impacto de migrar a microservicios con datos de tu equipo: número de engineers, experiencia, SLA, tasa de despliegue.
    • Evaluar coste total (TCO) en un año para añadir Redis vs. escalar PostgreSQL.
    • Lista de riesgos de una librería nueva: breaking changes, incompatibilidades, vulnerabilidades CVE.

    Prompt ejemplo (útil y directo):

    Contexto: “Somos un SaaS B2B, 5 devs (3 seniors), 200k DAU, TypeScript-only; AWS con presupuesto limitado.”

    Restricción: “No queremos downtime mayor a 15 minutos; presupuesto máximo $700/mes.”

    Objetivo: “Actúa como Staff Engineer. Compara Redis vs. escalar Postgres: 3 pros, 3 contras y una recomendación con costos estimados y pasos para PoC.”

    Resultado esperado: una tabla clara, supuestos enumerados y una ruta de prueba.

    2) Automatización operativa con n8n (o tu herramienta favorita)

    Tu tiempo es el recurso más caro. Automatiza el ruido.

    Flujos que te devuelven tiempo:

    • Triage automático de issues: n8n escucha GitHub/Jira, manda el diff a un LLM, recibe severidad y asigna según ownership y contexto histórico.
    • Resúmenes de PRs: ejecuta un job que lee el diff y devuelve: propósito, riesgos, tests necesarios y archivos críticos.
    • Monitoreo inteligente: envía logs a la IA para obtener hipótesis de causa raíz y posibles hotfixes.

    Prompt para triage (n8n):

    “Lee el issue + últimos 3 PRs relacionados. Resume en 5 líneas: causa probable, riesgo para producción, prioridad (alta/media/baja) y quién es el mejor propietario del ticket en base al historial de commits.”

    Beneficio inmediato: menos contexto que dar, menos back-and-forth. Menos tiempo perdido en reuniones.

    3) Desbloqueo del equipo y deuda técnica

    Un Tech Lead pasa más tiempo desatascando que programando. La IA puede ser tu extensión para mentoring y refactor.

    Usos prácticos:

    • Saca la lógica de negocio de código legacy y propon refactors por módulos.
    • Genera tests unitarios y E2E a partir de ejemplos de entrada/salida.
    • Crea documentación interactiva: endpoints, contratos, diagramas de flujo.

    Ejemplo real: Envías un módulo viejo. La IA devuelve: resumen de responsabilidades, funciones que romperías en microservicio, lista de pruebas necesarias y una propuesta de migración en 3 pasos.

    Advertencias (sí, las hay)

    No todo lo que brilla es oro. Hay zonas grises que tenés que vigilar.

    1. Privacidad y fuga de datos

    No mandes PII, credenciales o lógica propietaria a modelos públicos sin control. Poca gente lo admite, pero muchas filtraciones ocurrieron por prompts mal protegidos.

    Solución: usa instancias privadas (Azure OpenAI, modelos on-prem), o anonimiza ejemplos antes de enviarlos.

    2. Alucinaciones

    Los LLMs pueden inventar integraciones, versiones o APIs que no existen. Siempre pide fuentes y valida con tests.

    Truco: pide “pasos reproducibles” y “comandos exactos”; si no pueden darte eso, sospecha.

    3. Dependencia del equipo

    Si tus juniors confían demasiado en la IA sin cuestionar, perdés capacidad crítica. Establecé normas: la IA propone; vos o un senior validan.

    Framework de prompts para Tech Leads (tu plantilla)

    • Contexto: 1-2 frases claras. Número de devs. Stack. SLAs.
    • Restricciones: presupuesto, tiempo, compatibilidad.
    • Objetivo: acción deseada (comparar, proponer, auditar).
    • Formato de respuesta: tabla, checklist, pasos para PoC.
    • Nivel de detalle: superficial / técnico / con comandos.

    Ejemplo corto:

    Contexto: “Equipo 6 devs, Node + TypeScript, PostgreSQL principal.”

    Restricción: “No cambiar DB por 3 meses. PoC en 2 semanas.”

    Objetivo: “Dame 3 alternativas de caché, pros/cons y comandos para configurar Redis en Docker.”

    Checklist rápido: ¿Usar IA o no?

    • Usá IA si:
      • Necesitás comparar alternativas con datos concretos.
      • Querés reducir tiempo en tareas repetitivas.
      • Querés generar documentación y tests base.
    • No la uses si:
      • El input contiene secretos sin anonimizar.
      • Buscás una validación final para producción sin revisión humana.
      • Es un tema HR o performance interpersonal.

    Plan de implementación en 3 pasos (hazlo esta semana)

    1. PoC de PR summaries (2 días)

    • Conecta webhook de PR a un script que envíe diff a un LLM.
    • Pide resumen en 5 líneas + riesgo + pruebas sugeridas.
    • Prueba con 10 PRs reales. Mide reducción de tiempo de revisión.

    2. Triage de issues con n8n (1 semana)

    • Monta un flujo que lea nuevos issues y devuelva severidad + owner.
    • Reglas: ojo con false positives. Ajusta modelo con feedback.

    3. Política de uso y privacidad (1 día)

    • Define qué se puede enviar a la IA.
    • Establece un proceso de validación humana para cambios en producción.

    Ejemplo concreto: Redis vs. Escalar Postgres (mini caso)

    Datos: 5 devs, 100k operaciones/segundo en lectura, 40% de latencia por consultas agregadas.

    Pregunta a la IA: “Compara Redis vs. escalar Postgres para reducir latencia de lectura bajo este escenario. 3 pros, 3 contras, estimación de costos y un PoC en 2 semanas.”

    Qué recibirás: tabla con pros/cons, supuestos (cache hits %), costos aproximados, pasos PoC (docker-compose para Redis, script de carga, test de latencia).

    Si haces el PoC, no olvides medir cache hit ratio, latencia p95 y coste total. Sin métricas, todo es opinión.

    Última sección: ética, cultura y liderazgo

    La IA no es neutral. Refuerza la cultura que la alimenta. Si tu equipo ya toma atajos, la IA los hará más rápidos. Si tu equipo discute, la IA será un catalizador de ideas.

    Tu trabajo como Tech Lead:

    • Definir límites.
    • Asegurar validación.
    • Fomentar el pensamiento crítico.

    Si querés profundizar en automatización y workflows para equipos técnicos, podés revisar Dominicode Labs como continuación lógica para PoCs y plantillas prácticas.

    FAQ

    Respuesta: No. La IA amplifica tu juicio y acelera tareas, pero las decisiones en producción deben pasar por validación humana.

    Respuesta: No envíes PII, credenciales ni lógica propietaria sin anonimizar. Usa instancias privadas o anonimiza antes de enviar.

    Respuesta: Pide supuestos explícitos, pasos reproducibles y comandos exactos. Verifica con tests automatizados y revisión de un senior.

    Respuesta: El plan recomendado es 2 días para un PoC básico de resúmenes de PRs: conectar webhook, enviar diffs y evaluar 10 PRs reales.

    Respuesta: Cache hit ratio, latencia p95 y coste total (TCO) son métricas imprescindibles.

    Respuesta: Establecé normas claras: la IA propone, un senior valida. Fomentá preguntas críticas y revisiones manuales periódicas.

  • Cómo planificar el uso de agentes de IA en desarrollo de software

    Cómo planificar el uso de agentes de IA en desarrollo de software

    Planning (Planificación): cómo diseñar el plan maestro para agentes de IA

    Tiempo estimado de lectura: 5 min

    • Ideas clave:
    • Planning = contrato: plan.md, architecture.md, rules.md como System Prompt persistente.
    • Usa sub-agents para investigar carpetas y devolver resúmenes estructurados sin contaminar el contexto principal.
    • Divide la Implementation en tareas atómicas con workflow reproducible y límites de iteración.
    • Validation = tests automáticos + revisiones IA + revisión humana estratégica.

    Introducción

    Planning (Planificación) debe estar en las primeras líneas de cualquier proyecto que vaya a delegar trabajo real a un agente de IA. Si no defines qué construir a alto nivel, estás firmando para que el modelo invente decisiones en tu código. En este artículo explico, con criterio técnico y ejemplos prácticos, cómo convertir la fase de Planning en la columna vertebral de un ciclo seguro: Planning → Implementation → Validation.

    Resumen rápido (lectores con prisa)

    Qué es: Planning es el contrato operativo que define objetivos, constraints, convenciones y métricas para agentes de IA.

    Cuándo usarlo: Antes de delegar tareas automatizadas o de permitir agentes a hacer commits/PRs.

    Por qué importa: Evita decisiones ad-hoc del modelo, reduce variance y protege la arquitectura.

    Cómo funciona: Documentos persistentes + sub-agents para investigación + slash commands + tests/verificación.

    Planning (Planificación): documentos, contratos y el System Prompt persistente

    Planear no es escribir un listado de features. Es crear el contrato que el agente deberá cumplir.

    Estructura mínima de plan.md

    Documentos Markdown como fuente de verdad. Crea plan.md, architecture.md, rules.md. Esos archivos son tu System Prompt persistente: contienen objetivos de negocio, constraints técnicas, convenciones de estilo, y métricas de aceptación (coverage, latencia, límites de tokens).

    # Objetivo
- Migrar dashboard a Standalone Components (Angular 22)
# Constraints
- No tocar auth-service
- Coverage Vitest >= 90%
# Verificación
- vitest --coverage
- linter/eslint

    Slash commands

    Slash commands: define comandos reutilizables que encapsulen workflows estándar. Ejemplos: /investigate src/, /plan-migration --module dashboard, /task run-tests. Implementarlos reduce variance entre prompts y evita “ad-hoc prompts” que inducen errores.

    No des todo el repo al agente principal. Haz que investigue sub-agents.

    Sub-agents: investigación sin contaminar contexto

    Definición

    Meter cientos de archivos en el contexto degrada el razonamiento. Solución: sub-agents.

    Sub-agent = proceso aislado que lee carpetas específicas, ejecuta análisis (dependencias, tree shakes, npm ls, hotspots de deuda técnica) y devuelve un resumen estructurado.

    Resultado típico de sub-agent

    Resultado típico de sub-agent:

    • Lista de archivos críticos
    • Dependencias vulnerables
    • Tests flaky detectados
    • Propuesta de subtareas

    Ese resumen alimenta el plan sin hinchar la ventana de contexto del agente principal. Implementa sub-agents como funciones serverless o procesos MCP (Model Context Protocol — Model Context Protocol) que expongan solo lo necesario.

    Implementation (Implementación): dividir para no quebrar

    La implementación es donde la disciplina se mide en errores y tiempo.

    Workflow por tarea

    Divide el plan en tareas atómicas: “Implementar validación JWT en auth.service.ts” en vez de “Crear auth”.

    1. /task [id] → agent genera cambios localmente.
    2. Ejecutar tests unitarios (vitest) y linters.
    3. Si todo OK → crear rama y PR con diff.
    4. Si falla → el agent itera (máx N veces) o marca bloqueo para revisión humana.

    Reglas imprescindibles

    Reglas imprescindibles: límite de iteraciones por tarea (p.ej. 3), --safe por defecto en comandos destructivos y ejecución en contenedores/DevContainers.

    Mantén trazabilidad: cada task debe registrar tokens consumidos, tiempo y resultado. Métricas simples que importan: tokens/tarea, tests rotos introducidos, tiempo humano por corrección.

    Validation (Validación): automatización + juicio humano

    Tests y revisiones automáticas

    No hay merge sin validación. Tests automáticos primero: suites unitarias, E2E (Playwright), coverage thresholds.

    Revisiones automáticas por IA: usa herramientas como CodeRabbit para revisar PRs. Estas herramientas detectan problemas de complejidad, seguridad y estilo antes de que pase a humano.

    Revisión humana estratégica

    Revisión humana estratégica: no valides línea por línea. Valida intención arquitectónica: ¿el cambio respeta architecture.md? ¿Introduce deuda oculta? ¿Hay trade-offs no documentados?

    Documenta las excepciones. Cada PR debe contener la referencia al segmento de plan.md que motiva el cambio.

    Patrones operativos y plantillas útiles

    Slash command template

    /task create
--id: migrate-dashboard-01
--scope: src/dashboard
--verify: vitest --coverage
--constraints: no-auth
--max-iter: 3

    Sub-agent summary schema

    {
  "files": [...],
  "hotspots": [...],
  "tests_flaky": [...],
  "recommendation": "split module, add tests"
}

    Estas plantillas convierten la improvisación en procesos reproducibles.

    Criterio para decidir si adoptar este flujo

    Adóptalo si:

    • Tienes stack moderno (TypeScript, Angular/React con tests).
    • Puedes aislar ejecución (Docker, DevContainers).
    • El equipo acepta medir: tokens por task, tests green rate.

    No lo adoptes si:

    • Tu repo es monolito sin tests.
    • No puedes auditar secrets y gastos.
    • No hay disciplina para documentar plan.md.

    Gobernanza y métricas mínimas

    Quota tokens por usuario/equipo (ej. $10–20/dev/día). Logs de sesión y transcripts almacenados. KPIs: tokens/tarea, %tasks auto-merged, tiempo humano por PR.

    Planning (Planificación) no es burocracia; es el ancla. Divide, documenta y aísla. Usa sub-agents para investigar, slash commands para repetir y tests + CodeRabbit para validar. Hazlo bien y evitarás que tus agentes escriban código sin responder a tu arquitectura. Esto no acaba aquí: define tu primer plan.md hoy y convierte esa decisión en política de equipo.

    Dominicode Labs

    Para equipos interesados en explorar patrones operativos y sub-agents como prácticas reproducibles, una continuación lógica es revisar recursos y experimentos en Dominicode Labs. Estos recursos documentan plantillas y flujos que complementan la estrategia expuesta arriba.

    FAQ

    ¿Qué debe contener exactamente plan.md?

    Debe incluir Objetivo, Constraints y Verificación. Ejemplo mínimo: objetivo del cambio, restricciones (p.ej. no tocar auth-service), y comandos de verificación (p.ej. vitest --coverage, linters).

    ¿Cómo funcionan los sub-agents sin filtrar contexto al agente principal?

    Los sub-agents analizan áreas específicas fuera del contexto principal y devuelven un resumen estructurado (archivos críticos, hotspots, tests flaky, recomendación). Solo ese resumen entra al agente principal.

    ¿Qué límites de iteración recomiendan por tarea?

    Un límite razonable es 3 iteraciones por tarea. Si excede, marcar bloqueo para revisión humana.

    ¿Qué herramientas de review automático recomiendan?

    Herramientas como CodeRabbit son adecuadas para detectar complejidad, seguridad y estilo antes de pasar a revisión humana.

    ¿Cómo se relaciona plan.md con el System Prompt persistente?

    Los documentos plan.md, architecture.md y rules.md actúan como System Prompt persistente: contienen objetivos, constraints, convenciones y métricas de aceptación que el agente debe respetar.

    ¿Qué métricas son imprescindibles para gobernanza?

    Ejemplos: tokens/tarea, %tasks auto-merged, tiempo humano por PR. Además, establecer cuotas de tokens por usuario/equipo y almacenar logs/transcripts.

    ¿Cuándo NO adoptar este flujo?

    No lo adoptes si tu repo es un monolito sin tests, no puedes auditar secrets/gastos o no hay disciplina para documentar plan.md.

  • Cómo usar IA para mejorar la gestión de equipos técnicos y decisiones críticas

    Cómo usar IA para mejorar la gestión de equipos técnicos y decisiones críticas

    ¿Cuánto cuesta no saber qué decir en una 1:1? ¿Cuánto vale una mala decisión que frena a todo el equipo un mes entero? Si tu respuesta no implica cambiar algo esta semana, entonces sigues jugando a ser manager por inercia.

    Tiempo estimado de lectura: 6 min

    • Ideas clave:
    • Usar IA en gestión es disciplina, no outsourcing emocional.
    • Estandariza prompts, protege privacidad y convierte guiones en tareas concretas.
    • Un framework de prompt (Rol, Contexto, Restricciones, Output) produce resultados reproducibles.
    • Mide impacto con métricas claras antes de escalar cambios.

    Poca gente habla de esto: la IA no es la que va a reemplazar a tu gente. Es la que te permite dejar de improvisar, estructurar conversaciones difíciles y que tus decisiones técnicas no parezcan recetas de cocina hechas a ojo.

    Te digo esto directo: usar IA para gestionar un equipo no es outsourcing emocional. Es crear disciplina. Es tener guiones, datos y planes de acción reproducibles. Y sí, vas a seguir siendo responsable de todo. La IA solo te prepara mejor.

    Resumen rápido (lectores con prisa)

    La IA aplicada a gestión ayuda a estructurar 1:1s, generar guiones empáticos y convertir feedback en tareas medibles. Úsala para preparar conversaciones y formular métricas; evita pegar datos sensibles en servicios públicos. Implementa prompts versionados y mide impacto antes de escalar.

    Por dónde empezar (sin sentimentalismos)

    1. 1) Usa la IA para preparar, no para reemplazar.
    2. 2) No metas datos sensibles en servicios públicos. Punto.
    3. 3) Estandariza prompts como versionas código. Y úsalo como primer borrador: tú editas, tú decides.

    Qué puede hacer la IA por ti (y lo que no)

    • Bien: estructurar 1:1s, generar guiones empáticos, identificar cuellos de botella de procesos, descomponer epics, preparar feedback con marco SBI, proponer tests y métricas para PoCs.
    • Mal: reemplazar tu empatía, calcular costes exactos de cloud sin contexto, saber qué pasa en casa de un desarrollador.
    • Útil: detecta patrones, propone preguntas que no humillan, formula checklists y pruebas, y te recuerda pasos que olvidas cuando estás cansado.

    Framework de uso: 4 bloques que debes incluir en cada prompt

    No le des a la IA “un problema”. Dale esto:

    1. Rol: “Actúa como Engineering Manager con 8 años en startups y 3 en infra crítica.”
    2. Contexto: stack, tamaño de equipo, presión del negocio, deadlines.
    3. Restricciones: privacidad, políticas de la compañía, recursos no disponibles.
    4. Output: formato exacto (script para 1:1, checklist de PoC, RFC, tests a añadir).

    Plantillas que funcionan (copiar y pegar)

    1) Preparar 1:1 con alguien que falla en plazos

    System: “Eres un Engineering Manager experimentado. Sé directo y empático.”

    User: “Help me prepare a 1:1 conversation with a developer who is struggling with deadlines. Context: mid-senior, works remoto, backlog includes refactor + feature launch in 3 weeks. Constraints: avoid accusatory tone; don’t escalate to HR yet. Output: 1) a 6-step script to run the 1:1, 2) 3 open questions to identify root cause, 3) 2 follow-up actions with deadlines.”

    Qué esperar: guion con apertura segura, preguntas para explorar impedimentos técnicos y personales, y acciones claras (acortar scope, pair programming, reassign).

    2) Analizar problemas de equipo (Five Whys + acciones)

    System: “Actúa como Agile Coach senior.”

    User: “Our team missed the epic deadline for 3 sprints. PRs take 4 days to review; QA rejects 30% of builds. Apply Five Whys and return: root causes, 3 immediate audits to run, and 2 process changes to implement this sprint.”

    Qué esperar: causas raíz (definición pobre de ready, reviewers sobrecargados, flaky tests), y pasos concretos (limitar PR tamaño, revisión por pares rotativa, pipeline flaky tests assault).

    3) Redactar feedback con SBI (para situaciones tensas)

    System: “Sé claro y constructivo. Usa SBI framework.”

    User: “Provide feedback for a senior who interrupts juniors in dailies. Output: 1) SBI phrasing, 2) 2 coaching questions, 3) suggested follow-up in 2 weeks.”

    Qué esperar: mensaje que señala la situación, comportamiento e impacto; preguntas que invitan a reflexión; plan de seguimiento.

    4) Planificar sprints complejos

    System: “Actúa como PM técnico y tech lead.”

    User: “Help plan a sprint to migrate payments to Stripe. Stack Node.js + Angular. Constraints: keep current features live, 2-week sprint, 3 devs. Output: 1) breakdown in 8 tasks, 2) risks & mitigations, 3) success metrics for PoC.”

    Qué esperar: tickets paralelizables (adapter, backendWebhook, dataMigration in small batches), riesgos (rollback plan, data-consistency), métricas (time-to-reconcile, error-rate).

    Cómo convertir guiones en acción real

    • Guarda la transcripción del 1:1 y automatiza un “summary” que quede en el ticket del empleado (sin PII si lo procesas en nube pública).
    • Transforma el feedback en tareas: “pair on X”, “reduce scope Y”, “test Z”.
    • Usa la IA para generar los tests que deberían existir tras el PoC. Pide ejemplos de test cases y scripts de carga.

    Privacidad y ética (no es negociable)

    • Nunca pegues nombres, salarios o datos médicos en un modelo público.
    • Usa instancias privadas, entornos on-prem o proveedores con Zero Data Retention.
    • Versiona prompts y audita salidas: registra qué prompt produjo qué recomendación y quién la aprobó.

    Medir para no decidir a ciegas

    Define métricas antes de implementar cambios:

    • Tiempo medio de entrega de PRs.
    • Porcentaje de builds rechazados por QA.
    • Tiempo medio para resolución de blockers.
    • Tiempo de onboarding para nuevas prácticas (medido tras 2–4 sprints).

    Cómo automatizar (sin convertirte en SRE)

    • Usa plantillas de prompt en tu docs de equipo (prompt-v1.0).
    • Integra en un workflow sencillo: PR → IA pre-check (process & mentorship hints) → humano revisa → acción.
    • Genera reportes semanales automáticos: “Top 3 impediments” y “2 quick wins”.

    Errores reales que veo y cómo evitarlos

    • Error: Usar la IA para decidir despidos. Solución: la IA puede estructurar evidencia, pero la decisión humana y la conversación personal siguen siendo tuyas.
    • Error: Pegar codebase entero en un chat público. Solución: anonimizar y usar entorno privado.
    • Error: confiar en la IA en temas legales o de compensación. Solución: consulta Legal & HR.

    Ejemplo práctico, paso a paso (5 minutos para preparar 1:1)

    1. Copia el contexto del dev (rol, tickets, fechas).
    2. Pega en el prompt de 1:1 (plantilla arriba).
    3. Recibe el guion: 2 minutos de lectura.
    4. Personaliza 3 frases clave (tu toque humano).
    5. En la reunión: usa el guion, toma notas, define 2 acciones y pon seguimiento en calendario.

    Cómo escalar cultura con IA sin destruirla

    • Enseña al equipo a usar las plantillas: que ellos también pidan guiones para conversaciones difíciles.
    • Publica ejemplos en la wiki: “cómo dar y recibir feedback”, construidos con IA pero aprobados por humanos.
    • Mide el impacto: hacen menos escaladas a Product o a HR? Se entregan más features?

    Checklist mínimo antes de usar IA en gestión

    • [ ] ¿Prompt versionado y aprobado por legal?
    • [ ] ¿Modelo privado o proveedor con Zero Data Retention?
    • [ ] ¿Seudónimos para datos sensibles?
    • [ ] ¿Métricas definidas para validar la acción?
    • [ ] ¿Plan de seguimiento (fechas y responsables)?

    Cultura de experimentación (hazlo iterativo)

    No prometas el paraíso. Promete pequeñas mejoras repetibles. Ejecuta esto en ciclos cortos:

    • Sprint 0: prueba 3 1:1 con IA.
    • Sprint 1: aplica cambios en la planificación y mide.
    • Sprint 2: amplía a todo el equipo si hay mejora.

    Cierre — lo práctico y lo urgente

    La IA te da estructura. Tú das la humanidad. Juntos pueden convertir reuniones tensas en conversaciones productivas, cuellos de botella en tareas concretas y decisiones en experimentos medibles.

    Esto no acaba aquí. Si quieres, te envío:

    • 10 prompts listos (1:1, feedback SBI, Five Whys, sprint planning).
    • Una plantilla RFC para cambios de proceso.
    • Un checklist de privacidad y métricas.

    Di “QUIERO EL KIT” y te lo paso todo en formato listo para pegar en tu Notion o repo. Y si prefieres que te arme el primer guion de 1:1 con un caso real (sin PII), pégame el contexto y lo preparo en 10 minutos.

    Si quieres integrar workflows y plantillas de prompts en tus procesos, revisa lo que hacemos en Dominicode Labs como continuación lógica para automatizar pasos repetibles y versionar prompts en tu equipo.

    FAQ

    ¿La IA puede reemplazar a un manager?

    No. La IA apoya en preparación y estructura, pero la responsabilidad humana en decisiones, empatía y conversaciones personales sigue siendo irremplazable.

    ¿Qué datos no debo poner en un prompt?

    Nombres, salarios, datos médicos y cualquier información identificable o sensible. Usa seudónimos y entornos privados para datos internos.

    Cómo mido si la IA está ayudando realmente

    Define métricas antes de aplicar cambios: tiempo medio de entrega de PRs, porcentaje de builds rechazados, tiempo de resolución de blockers y tiempo de onboarding para nuevas prácticas.

    ¿Debo versionar mis prompts?

    Sí. Versiona prompts como código, registra quién aprobó cambios y audita salidas para trazar decisiones y mejoras.

    Qué hacer si una recomendación de IA contradice a HR

    Prioriza la política de HR. Usa la IA para estructurar evidencia, pero consulta a HR y Legal antes de acciones sensibles como despidos o cambios contractuales.

    ¿Puedo usar prompts públicos para casos con PII?

    No. Nunca pegues PII en modelos públicos; usa instancias privadas o proveedores con políticas de retención cero y anonimiza datos cuando sea necesario.

  • Integración de Gemini Nano con Angular para IA Local en el Navegador

    Integración de Gemini Nano con Angular para IA Local en el Navegador

    Integración de Gemini Nano con Angular: IA Local en el Navegador

    Tiempo estimado de lectura: 5 min

    Ideas clave

    • Gemini Nano puede ejecutarse on-device en Chrome mediante la Prompt API / LanguageModel API experimental, evitando enviar datos a la nube.
    • Recomienda abstraer el acceso a window.LanguageModel en un servicio Angular inyectable y exponer estados reactivos con Signals.
    • Implementa fallback a la nube (Vertex AI, OpenAI, etc.) si el modelo on-device no está disponible.
    • Prepárate para descargas iniciales de pesos, impacto en recursos del cliente y cambios en la API; ofrece métricas y UX claras.

    Tabla de contenidos

    Resumen rápido (lectores con prisa)

    Gemini Nano permite ejecutar modelos de lenguaje on-device en Chrome mediante una Prompt API experimental. Úsalo para operaciones sensibles a la privacidad y bajas latencias; diseña un servicio Angular que abstraiga window.LanguageModel, exponga estados con Signals y ofrezca fallback a la nube.

    Qué necesitas activar y por qué importa

    Gemini Nano llega al frontend vía la Prompt API / LanguageModel API que Chrome está probando. Es experimental: hay que habilitar flags y aceptar descargas iniciales del modelo en el cliente. Hazlo solo en entornos controlados.

    Puntos prácticos

    • Abre chrome://flags y habilita las flags relacionadas con Prompt API (busca “Prompt API” / “on-device model”).
    • Revisa chrome://components y chrome://on-device-internals para estado y métricas.
    • La primera ejecución puede descargar pesos (depende de la build). Avisa al usuario con un estado de “descarga en progreso”.

    Referencias útiles

    Arquitectura recomendada en Angular

    Regla número uno: no uses window directamente en componentes. Abstrae todo en un servicio inyectable que gestione disponibilidad, descarga y sesión. Usa Signals para exponer estados reactivos y facilitar la integración con componentes.

    global.d.ts (tipos mínimos)

    declare global {
  interface Window {
    LanguageModel?: {
      availability(options?: any): Promise;
      create(options?: any): Promise;
    };
  }
}
export {};

    Servicio Angular (esqueleto)

    import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class GeminiNanoService {
  isAvailable = signal<'checking'|'available'|'unavailable'>('checking');
  isReady = signal(false);
  private session: any = null;

  constructor() {
    this.checkAvailability();
  }

  async checkAvailability() {
    if (!window.LanguageModel) {
      this.isAvailable.set('unavailable');
      return;
    }
    try {
      const status = await window.LanguageModel.availability({
        expectedInputs:[{type:'text'}], expectedOutputs:[{type:'text'}]
      });
      this.isAvailable.set(status === 'available' ? 'available' : 'unavailable');
      if (this.isAvailable() === 'available') await this.init();
    } catch {
      this.isAvailable.set('unavailable');
    }
  }

  private async init() {
    this.session = await window.LanguageModel!.create({
      // monitor: callback para progreso de descarga si aplica
    });
    this.isReady.set(true);
  }

  async prompt(text: string, opts?: any) {
    if (!this.session || !this.isReady()) throw new Error('Gemini Nano no listo');
    return await this.session.prompt(text, opts);
  }
}

    Usa APP_INITIALIZER si quieres bloquear rutas hasta que la disponibilidad esté verificada.

    Patrones de uso: Resúmenes y Smart Paste

    Dos patrones repetibles son útiles: resúmenes client-side y Smart Paste para estructurar texto del portapapeles. Úsalos cuando la privacidad y la latencia local sean prioritarias.

    1) Resúmenes client-side

    • Ideal para emails, tickets y documentación sensible.
    • Prompt corto, instrucciones claras y límites (p. ej. “tres bullets”).
    const prompt = `Resume en 3 viñetas técnicas, sin ejemplos ni explicaciones: ${longText}`;
const summary = await geminiService.prompt(prompt);

    2) Smart Paste (estructurar texto del portapapeles)

    Intercepta ClipboardEvent, manda el texto al modelo y pide JSON estricto. Valida con JSON.parse y aplica patchValue en FormGroup.

    Ejemplo de prompt:

    Extrae nombre, cargo, empresa y teléfono del texto y responde SOLO con JSON válido.
Texto: "..."

    Consejo: limpia la respuesta de bloques de código (“`json) antes de parsear.

    Estrategia híbrida: fallback a la nube

    La API es experimental y puede no estar disponible en todos los usuarios. Diseña un fallback:

    • Servicio expone promptLocal() y promptCloud().
    • Lógica: si isReady() → local; si no → cloud (Vertex AI, OpenAI, etc.).
    • Mantén la misma interfaz para consumidores.
    async prompt(input:string){
  return this.isReady() ? this.promptLocal(input) : this.promptCloud(input);
}

    Limitaciones y decisiones técnicas

    No es magia. Decide por criterios claros:

    • Privacidad vs Capacidad: on-device evita enviar datos, pero modelos locales suelen ser más limitados en razonamiento y factualidad.
    • Recursos del cliente: descarga inicial y uso de RAM/GPU. Ofrece UI de progreso y posibilidad de desactivar la característica.
    • Inestabilidad: la API puede cambiar; encapsula y prueba en Canary/Dev builds.

    Buenas prácticas de implementación

    • Aisla feature flags para habilitar/deshabilitar en producción.
    • Expón métricas de adopción y errores (no datos sensibles).
    • Documenta UX: indica cuándo la funcionalidad requiere descarga y ofrece opción “Usar IA en la nube”.
    • Testea en dispositivos representativos de tus usuarios (PCs y Chromebooks, no asumas móviles).

    La integración de Gemini Nano con Angular no es un truco de marketing: es una arquitectura pragmática para reducir latencia, mejorar privacidad y sacar tareas concretas del backend. Implementa la abstracción, prevé el fallback y deja el modelo decidir cuándo merece la pena correr on-device. Esto apenas comienza: prueba en controlado, mide impacto y ajusta el balance on-device / cloud.

    Dominicode Labs ofrece un espacio para experimentar con integraciones de IA aplicada y workflows relacionados; puede servir como referencia para pruebas controladas y métricas de adopción.

    FAQ

    ¿Qué es Gemini Nano en el contexto del navegador?

    Es una implementación on-device de modelos de lenguaje accesible mediante la Prompt API / LanguageModel API experimental de Chrome, que permite ejecutar inferencia local en el navegador sin enviar datos a la nube.

    ¿Qué flags y páginas de Chrome debo revisar?

    Habilita las flags relacionadas con Prompt API en chrome://flags y revisa estado y métricas en chrome://components y chrome://on-device-internals.

    ¿Cómo debo abstraer la API en Angular?

    Crea un servicio inyectable que gestione disponibilidad, descarga y sesión; no uses window directamente en componentes. Exponer estados con Signals facilita la integración reactiva y el bloqueo de rutas con APP_INITIALIZER si es necesario.

    ¿Cuándo usar fallback a la nube?

    Implementa fallback cuando isReady() sea false o cuando el dispositivo no soporte la ejecución on-device. Mantén la misma interfaz para que consumidores no distingan origen (local vs cloud).

    ¿Qué impacto tiene en recursos del cliente?

    Puede requerir descarga inicial de pesos y uso adicional de RAM/GPU. Ofrece UI de progreso, opción para desactivar la característica y prueba en dispositivos representativos.

    ¿Cómo validar respuestas estructuradas como JSON?

    Pide al modelo que responda SOLO con JSON válido, limpia posibles bloqueos de código (“`json) y usa JSON.parse para validar antes de aplicar patchValue en formularios.

  • Construcción de memoria efectiva en agentes de LLMs

    Construcción de memoria efectiva en agentes de LLMs

    ¿Quieres que tu agente recuerde cosas útiles… o que haga como si recordara y te deje colgado en la siguiente conversación?

    Tiempo estimado de lectura: 7 min

    • Separar memoria corta y larga: la conversación viva debe manejarse aparte de hechos estructurados.
    • Extraer hechos estructurados: usar un extractor que emita JSON y aplicar UPSERT/DELETE, no append infinito.
    • Decisiones arquitectónicas: síncrono vs asíncrono, versionado y locks para evitar race conditions.
    • Optimizar costes: usar modelos baratos para extracción, modelos premium solo para generación crítica.
    • Observabilidad y Gobernanza: logs, métricas, cifrado y políticas de retención son imprescindibles.

    Poca gente habla de esto: la memoria en agentes no es un problema de “mandar el historial” al modelo. Es un problema de arquitectura, coste y criterio. Hacerlo mal es pagar tokens, cargar latencia y, lo peor, construir una ilusión de memoria que falla cuando más importa.

    Te voy a contar, sin florituras, cómo se construyó el sistema de memoria de Agent Builder y qué decisiones concretas puedes tomar hoy para replicarlo sin pelearte con un monster framework.

    Resumen rápido (lectores con prisa)

    Separar memoria corta (últimos N mensajes) de memoria larga (hechos estructurados). Usar un extractor barato que devuelva JSON forzado con operaciones UPSERT/DELETE. Preferir extracción asíncrona por defecto y checkpoints síncronos para acciones críticas. Versionado y locks para evitar race conditions; observabilidad y gobernanza desde el día 1.

    Primera verdad incómoda

    Primera verdad incómoda: los LLMs no recuerdan.

    Cada petición es una hoja en blanco. Si quieres que el agente actúe con coherencia, tienes que diseñar la memoria fuera del modelo.

    Resumen rápido del approach que funciona

    • Separar memoria a corto plazo (conversación viva) de memoria a largo plazo (hechos estructurados).
    • Extraer hechos con un LLM dedicado (extractor) y guardarlos como pares clave-valor o documentos estructurados.
    • Forzar salidas en JSON (Tool Calling) para que la memoria sea determinista.
    • Resolver conflictos con UPSERT/DELETE, no con append infinito.
    • Decidir entre extracción síncrona o asíncrona según prioridades (latencia vs coherencia).

    1) Memoria a corto plazo: lo que vive ahora

    ¿Qué es? Los últimos N mensajes del hilo (thread_id).

    Para qué sirve: referencias inmediatas (“bórralo”, “ese archivo”, “la última tarea”).

    Implementación simple: Redis o una tabla en Postgres con TTL y lista acotada.

    Por qué importa: reduce tokens enviados al LLM principal y mantiene claridad a corto plazo.

    2) Memoria a largo plazo: hechos, no chats

    No guardes el chat crudo. Guarda hechos estructurados: preferencias, roles, reglas de negocio, acciones ya realizadas.

    ¿Cómo se obtienen? Un LLM extractor lee el hilo (o el resumen) y emite objetos JSON con campos tipo {key, value, source, timestamp, confidence}.

    Dónde guardarlos: una tabla Key-Value en Postgres o en Redis para lecturas rápidas; opcionalmente, una base vectorial si necesitas búsquedas semánticas sobre fragmentos largos.

    3) El extractor: el héroe silencioso

    Debe ser un LLM barato y rápido (GPT-4o-mini, Claude 3 Haiku o un modelo local si tienes infra).

    Se le da: el hilo reciente + la memoria actual (opcional, si quieres que compare).

    Debe devolver: operaciones del tipo {op: “UPSERT”, key: “pref_theme”, value: “dark”, reason: “…”} o {op: “DELETE”, key: “pref_theme”, reason: “…”}.

    Forzar JSON es obligatorio. Si el modelo alucina, valida la salida con un schema validator (Zod, JSON Schema).

    4) Resolver conflictos: no más “y también”

    Problema típico: ayer dije “React”, hoy “Angular” y el sistema almacena ambos.

    Solución: lógica de reconciliación dentro del extractor — recibe la memoria existente y decide overwrites o borrados.

    Políticas útiles: última declaración gana para preferencias personales; para estados transaccionales usar confirmación explícita (“Confirmo que he migrado a Angular”).

    5) Síncrono vs Asíncrono — la decisión que rompe equipos

    Síncrono: esperas a que el extractor actualice la memoria antes de responder. Plus: coherencia. Contra: latencia.

    Asíncrono: respondes al usuario y actualizas memoria en background. Plus: experiencia rápida. Contra: race conditions si el usuario dispara múltiples mensajes seguidos.

    Recomendación práctica: asíncrono por defecto, con checkpoints síncronos en operaciones críticas (ej. ejecutar acciones que dependen de la memoria: “programa el pago” → usa extracción síncrona o confirmación humana).

    6) Mitigar race conditions: patrones que funcionan

    • Versionado por evento: cada update incluye un version_id. Si un job en background llega con versión vieja, lo descarta.
    • Locks optimistas: comparar-timestamps antes de aplicar UPSERT.
    • Event sourcing ligero: mandar events al bus (Kafka, Redis Streams) y procesarlos ordenadamente.
    • Si necesitas garantía fuerte, usa transacciones y bloqueo por llave (Postgres advisory locks).

    7) Costes y optimización de tokens

    No envíes texto innecesario al LLM principal. Inyecta solo facts relevantes (top-K) y un resumen de contexto.

    Batch extraction: agrupa varias interacciones y extrae cada X minutos si no hay acciones críticas.

    Usar modelos cheap para extractor y modelos premium para generación cuando haga falta.

    8) Observabilidad y LLMOps: no es opcional

    • Logea: inputs al extractor, salidas JSON, ops aplicadas (UPSERT/DELETE), latencias, errores de parsing.
    • Métricas clave: TTFT, tiempo de extracción, tasa de conflictos, porcentaje de respuestas incoherentes relacionadas con memoria.
    • Guarda trazabilidad para auditoría (what was injected, when, by which extractor) — imprescindible si manejas PII.

    9) Privacidad y gobernanza

    • Nunca almacenes datos sensibles sin cifrado y consentimiento.
    • Tokeniza o anonimiza cuando sea posible.
    • Control de accesos: solo servicios autorizados pueden leer/escribir la memoria.
    • Políticas de retención: define cuánto tiempo quedan los hechos y cómo se borran permanentemente.

    10) Tests y validación

    • Tests unitarios de extractor: inputs -> JSON schema válido.
    • Integración: simula secuencias de diálogos para validar conflict resolution.
    • E2E: pruebas que cubran casos de race conditions y rollback.
    • Prueba manual de A/B: compara comportamiento con y sin memoria en producción limitada.

    11) Stack recomendado mínimo (para lanzar rápido)

    • Storage corto: Redis (listas con TTL)
    • Storage largo: Postgres (tabla kv con versioning) + opcional vector DB (Pinecone/Qdrant)
    • Orquestador: n8n / Lambda / Sidecar service
    • Extractor model: GPT-4o-mini / Claude 3 Haiku (económicos)
    • Generación model: GPT-4o / Claude 3 Sonnet (cuando necesites calidad)
    • Validación: JSON Schema + Zod en backend
    • Observabilidad: logs estructurados + Sentry / Datadog

    12) Checklist práctico para ponerlo en producción (si te gusta lo concreto)

    • [ ] Definir qué “hechos” guardas (user_prefs, last_actions, contracts_signed, etc.).
    • [ ] Implementar almacenamiento corto (Redis) y largo (Postgres).
    • [ ] Crear extractor con JSON forced output y validar schema.
    • [ ] Implementar operaciones UPSERT/DELETE con versionado.
    • [ ] Diseñar flujo asíncrono por defecto y rutas síncronas para operaciones críticas.
    • [ ] Añadir metrics y logs para cada extracción y operación.
    • [ ] Revisar PII/retención y cifrado en reposo y en tránsito.
    • [ ] Tests automáticos para race conditions y reconciliación.
    • [ ] Plan de rollback si una actualización de prompt rompe el extractor.

    Metáfora que guarda la idea

    La memoria del agente no es una mochila donde tiras todo el chat. Es una libreta indexada. Solo apuntas lo que te sirve, lo fechas, lo restructuras y borras lo viejo. Si apilas notas sin orden, la libreta es ruido. Si la estructuras, te salva.

    Historias reales (1 párrafo cada una)

    El equipo A metió todo el historial en cada prompt: coste x10, latencias enormes y usuarios desconectados. Migraron a extractor asíncrono y bajaron costes un 70%.

    El equipo B aseguró cada operación con versión y locks: sacrificaron un poco de velocidad, pero nunca perdieron coherencia en flujos transaccionales.

    El equipo C dejó la extracción en background y puso un checkpoint síncrono antes de ejecutar pagos — ganador en UX y seguridad.

    Cierre con decisión: ¿lo haces tú o lo dejas para después?

    Construir memoria útil no es sexy. Es ingeniería, decisiones difíciles y pruebas. Pero sin ella, tu “agente” será otro bot que habla bonito y olvida todo. Si quieres lanzar algo que realmente parezca inteligente, hazlo con lógica, no con parcheos.

    Si quieres la checklist descargable, un prompt extractor listo para copiar/pegar y un mini-plan de 30 días para implementar esto en tu stack, respóndeme “QUIERO MEMORIA” y te lo mando. Esto no acaba aquí — y si no empiezas hoy, otro equipo lo hará.

    Como continuación lógica para quienes trabajan en automatización, agentes y workflows, puedes encontrar recursos y experimentos en Dominicode Labs.

    FAQ

    Respuesta: ¿Qué diferencia hay entre memoria a corto y a largo plazo?

    La memoria a corto plazo contiene los últimos N mensajes del hilo y sirve para referencias inmediatas. La memoria a largo plazo almacena hechos estructurados (preferencias, roles, acciones realizadas) que deben persistir y consultarse por el agente cuando sea relevante.

    Respuesta: ¿Por qué no guardar el chat completo?

    Guardar el chat crudo aumenta costes (tokens), latencia y ruido. Es mejor extraer hechos útiles y estructurarlos para lecturas rápidas y deterministas.

    Respuesta: ¿Qué es un extractor y qué formato debe devolver?

    Un extractor es un LLM barato y rápido que lee el hilo o su resumen y devuelve operaciones en JSON forzado, por ejemplo {op: “UPSERT”, key: “…”, value: “…”, reason: “…”}. La salida debe validarse con un schema validator.

    Respuesta: ¿Cuándo usar extracción síncrona en lugar de asíncrona?

    Usa extracción síncrona para operaciones críticas que dependen inmediatamente de la memoria (ej. ejecutar pagos). Por defecto, asíncrono para mejor UX y menor latencia, con checkpoints síncronos donde haga falta.

    Respuesta: ¿Cómo mitigo race conditions en actualizaciones de memoria?

    Patrones efectivos: versionado por evento (version_id), locks optimistas (comparar timestamps), event sourcing ligero y, si necesitas garantías fuertes, transacciones y bloqueo por llave en Postgres.

    Respuesta: ¿Qué métricas debo monitorizar?

    Métricas clave sugeridas: TTFT, tiempo de extracción, tasa de conflictos y porcentaje de respuestas incoherentes relacionadas con memoria. Además, loggear inputs, salidas JSON y ops aplicadas para trazabilidad.

    Respuesta: ¿Qué precauciones de privacidad aplicar?

    Nunca almacenar datos sensibles sin cifrado y consentimiento. Tokenizar o anonimizar cuando sea posible, controlar accesos y definir políticas de retención claras.

  • Cómo implementar evaluaciones automatizadas para agentes de IA

    Cómo implementar evaluaciones automatizadas para agentes de IA

    Testing Your AI Agent Skills

    Testing Your AI Agent Skills debe ser el primer paso después de escribir un SKILL.md. Si no tienes una suite de evals automatizados, lo que hoy llamas “skill” es un prototipo frágil: funciona en local tres veces y falla en producción cuando más importa. Aquí explico cómo pasar de sensaciones a ingeniería sólida, con ejemplos prácticos, métricas y scripts que puedes integrar hoy mismo.

    Tiempo estimado de lectura: 4 min

    • Automatiza evals: una skill sin evaluación automatizada es frágil; integra graders deterministas y repite trials.
    • Métricas claras: mide capacidad (pass@k), fiabilidad (pass^k) y correctitud (grader determinista con exit codes).
    • Aislamiento: usa Docker para cada trial y destruye el entorno tras la verificación.
    • Repetición: ejecuta >=5 trials para estimar estabilidad; optimiza para pass^k alto antes de producción.

    Testing Your AI Agent Skills: por qué importa y qué mide un eval

    Una Skill no es un prompt bonito: es documentación ejecutable que un agente usa para actuar. Cambiar una instrucción, reordenar pasos o quitar una verificación puede romper el comportamiento sin avisos. Los LLMs son no deterministas; una ejecución exitosa no prueba nada. Los evals automatizados solucionan eso midiendo tres cosas:

    • Capacidad (pass@k): ¿puede el agente resolver la tarea al menos una vez en k intentos?
    • Fiabilidad (pass^k): ¿la resuelve todas las veces en k intentos?
    • Correctitud (grader determinista): ¿el resultado cumple la condición objetiva (compila, lint pasa, tabla creada)?

    Un ejemplo realista de comando que debes poder ejecutar en CI:

    GEMINI_API_KEY=your-key npm run eval superlint -- --provider=docker --trials=5

    Eso encapsula aislamiento (Docker), repetición estadística (trials) y la unidad de test (la skill superlint).

    Repositorio de referencia: https://github.com/mgechev/skill-eval

    Arquitectura mínima de un eval efectivo

    Cada tarea debe ser autocontenida y reproducible. Estructura sugerida:

    tasks/my_task/
├── task.toml           # timeouts, recursos, límites
├── instruction.md      # el prompt único para el agente
├── environment/Dockerfile
├── tests/test.sh       # grader determinista (shell)
├── prompts/quality.md  # grader de rúbrica (opcional)
├── solution/solve.sh   # referencia
└── skills/my_skill/
    └── SKILL.md

    Principios clave:

    • El agente recibe solo instruction.md como prompt primario. Las skills viven en rutas de descubrimiento estándar (.agents/skills/ o .claude/skills/).
    • Los graders deterministas deben ser código: scripts que ejecutan eslint, npm test o consultas SQL y devuelven PASS/FAIL.
    • Usa Docker para aislar cada trial y destruir el contenedor tras la verificación. Documentación Docker: https://www.docker.com/

    Ejemplo práctico: verificador determinista para superlint

    Si la tarea es “arreglar errores de lint”, el grader no puede ser subjetivo. Un ejemplo de tests/test.sh:

    #!/usr/bin/env bash
set -e
# Ejecuta eslint en la ruta de trabajo
npx eslint main.js --max-warnings=0
if [ $? -eq 0 ]; then
  echo "PASS"
  exit 0
else
  echo "FAIL"
  exit 1
fi

    No preguntes al LLM “¿lo hiciste bien?”. Ejecuta eslint (https://eslint.org) y deja que el exit code decida.

    Repetición y métricas: por qué 5 trials no es arbitrario

    Los LLMs introducen variabilidad. Ejecutar 5 trials te da una muestra mínima para estimar estabilidad. Interpretación práctica:

    • pass@5 = 100% y pass^5 = 100% → listo para producción.
    • pass@5 = 100% y pass^5 = 30% → el agente puede hacerlo, pero es flaky; no desplegar.
    • pass@5 < 80% → la skill necesita rediseño (más contexto, scripts deterministas, aclaraciones en SKILL.md).

    Para workflows críticos (migraciones, despliegues), fija umbral >= 90% pass^k.

    Integración CI: Quality Gate para Skills

    Añade un job que corra los evals en cada PR que toque skills/ o tasks/:

    name: Skill Eval
on:
  pull_request:
    paths: ['skills/**', 'tasks/**']

jobs:
  eval:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: GEMINI_API_KEY=${{ secrets.GEMINI_API_KEY }} npm run eval my_task -- --trials=5 --provider=docker

    Si la tasa de éxito cae por debajo del umbral, el PR queda bloqueado con el output del eval (trials individuales, logs, grader output). Esa transparencia es crítica para debugging rápido.

    Diagnóstico accionable cuando fallan trials

    Un buen eval no solo marca FAIL; explica por qué. Ejemplo de salida útil:

    Trial 1: FAIL - Agent ran 'eslist --lint' (typo)  
Trial 2: PASS  
Trial 3: FAIL - Agent modified src/utils.js instead of src/main.js  
Trial 4: PASS  
Trial 5: PASS

    Con esa trazabilidad ajustas SKILL.md o scripts (p. ej., forzar paths absolutos, añadir checks previos, mejorar error handling en scripts).

    Recomendaciones finales y checklist rápido

    • Mantén SKILL.md corto y prescriptivo; externaliza lo frágil a scripts/.
    • Usa Docker para todos los evals que toquen filesystem o red.
    • Implementa graders deterministas como contrato (stdout JSON + exit codes).
    • Ejecuta >=5 trials; optimiza para pass^k en producción.
    • Integra evals en CI como Quality Gate.
    • Mantén dataset de pruebas realistas (repos con edge-cases), no solo ejemplos sintéticos.

    Testing Your AI Agent Skills no es opcional. Si confías en agentes para tocar código o infra, mide su comportamiento bajo condiciones reproductibles. Implementa evals hoy y transforma tus skills de “probablemente funcionan” a “sabemos que funcionan”.

    Como continuación lógica a estos procesos y para explorar integraciones y experimentos prácticos con evaluaciones de skills y pipelines de CI, visite Dominicode Labs. Allí encontrará recursos y ejemplos orientados a equipos de ingeniería que automatizan agentes y workflows.

    FAQ

    ¿Qué es un eval para una Skill?

    Un eval es una prueba autocontenida y reproducible que ejecuta una skill contra un grader determinista para verificar comportamiento objetivo (por ejemplo, lint pasa, tests verdes, tabla creada).

    ¿Cuántos trials debo ejecutar?

    Ejecuta al menos 5 trials para estimar estabilidad. Ese número proporciona una muestra mínima para analizar variabilidad en LLMs.

    ¿Por qué usar Docker en cada trial?

    Docker aísla el entorno, evita efectos laterales entre trials y garantiza reproducibilidad. Además permite destruir el contenedor tras la verificación.

    ¿Cómo debe devolver resultados un grader?

    Como código: exit codes y stdout estructurado (por ejemplo JSON). Evita evaluaciones subjetivas; usa herramientas como eslint o npm test.

    ¿Qué hacer si pass@k es alto pero pass^k es bajo?

    No desplegar. Señala que la skill es flaky; mejora el prompt, agrega verificaciones adicionales o externaliza pasos frágiles a scripts deterministas.

    ¿Qué umbral usar en producción?

    Para workflows críticos, fija umbral ≥ 90% en pass^k. Ajusta según riesgo y gravedad del fallo.