DOMINICODE

Category: AI

  • 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).

  • Implementa autenticación sencilla en Next.js con NextAuth.js

    Implementa autenticación sencilla en Next.js con NextAuth.js

    NextAuth.js / Auth.js: deja de reinventar la autenticación

    Tiempo estimado de lectura: 6 min

    Ideas clave

    • NextAuth.js (y la evolución a Auth.js v5) evita errores comunes en sesiones, cookies y tokens.
    • Dos estrategias de sesiones: JWT (performance) vs sesiones en base de datos (revocación instantánea).
    • Evita gestionar credenciales si no dominas hashing, salting y políticas de seguridad.
    • Si usas Next.js 14+, técnica y pragmáticamente conviene empezar con Auth.js (v5).

    Tabla de contenidos

    ¿Cansado de perder semanas armando autenticación como si fuera magia negra? Eso se acaba aquí.
    NextAuth.js no es solo otra librería bonita. Es el pegamento que evita que tu aplicación se desangre en sesiones, cookies y tokens. Es la forma razonable de decir: “No voy a reinventar esto” y, aun así, tener control total.

    Resumen rápido (lectores con prisa)

    NextAuth.js es una solución de autenticación open source diseñada para Next.js y arquitecturas Serverless. Úsala para gestionar sesiones, providers OAuth y passwordless sin construir todo desde cero. Importa porque abstrae validación en peticiones y reduce errores de cookies/tokens. Funciona con JWT o sesiones en base de datos según tus necesidades de rendimiento y revocación.

    Qué es, en pocas palabras

    NextAuth.js es una solución de autenticación open source creada para Next.js. Funciona bien con Serverless, Edge y App Router. No pretende sustituir a un proveedor de identidad empresarial, pero te da una capa de seguridad sólida, lista para producción, sin pagar licencia.
    Es como poner una cerradura profesional en la puerta de tu app sin contratar a un cerrajero. Es segura por defecto. Y flexible cuando lo necesitas.

    Por qué importa en el mundo moderno (y no es marketing)

    Next.js con App Router difumina la línea entre servidor y cliente. Ahora puedes ejecutar lógica en el servidor sin servidor fijo. Eso complica cookies, tokens y el control de sesiones. Si lo haces mal, expones rutas, filtrás datos y te conviertes en el peor tipo de soporte: el que responde “está en producción, no puedo tocarlo”.
    NextAuth.js abstrae eso. Valida en el momento de la petición, ideal para funciones Serverless o runtimes Edge. No necesitas un proceso que viva todo el tiempo. Ahorras costes. Escalas mejor. Y, sobre todo, reduces la superficie de errores humanos.

    Características que realmente importan

    No voy a pintarte una lista vacía. Esto es lo importante:
    • Soporte multi-proveedor (OAuth): conecta Google, GitHub, Apple, Discord, lo que sea. No reinventes OAuth.
    • Magic Links (passwordless): menos fricción, menos contraseñas que filtrar.
    • Adapters para DB y ORMs: Prisma, Drizzle, Mongo, Supabase. Tú eliges dónde almacenarlos.
    • Seguridad por defecto: CSRF, firma de cookies, tokens cifrados (JWE) —activados sin tener que leer 200 páginas.
    • Edge-ready: puedes validar sesiones casi al instante si lo ejecutas cerca del usuario.
    No es perfecto, pero es un buen comienzo. Y un comienzo con sentido.

    El dilema clásico: manejar credenciales propias

    Puedes usar el proveedor de “credentials” y manejar usuarios/contraseñas tú mismo. Suena bien hasta que lees la letra pequeña: gestionar contraseñas implica responsabilidad. Hashing, salting, políticas, reset de contraseñas, protección frente a ataques por fuerza bruta.
    NextAuth.js permite credenciales, pero la recomendación oficial y práctica es evitarlo si no sabes exactamente lo que haces. Además, si usas ese proveedor, NextAuth.js fuerza sesiones en JWT y desactiva sesiones en BD. No es capricho: es una decisión para reducir malas prácticas.

    Arquitectura de sesiones: dos caminos y una decisión

    Aquí viene la parte que separa proyectos tranquilos de proyectos que arden. Hay dos estrategias principales:

    1) JWT (por defecto)

    La información viaja en la cookie, cifrada. Rápido. No consultas la DB en cada petición. Ideal para apps con mucho tráfico. Problema: invalidar sesiones inmediatamente es más complejo. Si quieres expulsar a alguien ya, el token sigue válido hasta que expire.

    2) Sesiones en base de datos

    La cookie guarda solo un ID. La verificación exige una consulta a la base de datos. Perfecto si necesitas cortar accesos en tiempo real (ej. revocar a un usuario). Coste: latencia adicional por cada validación.
    No hay una respuesta universal. Si tu app es una red social con millones de peticiones, JWT suele ser la opción. Si es un panel de control bancario donde cortar accesos rápido es crítico, la base de datos gana.

    La transición que incomoda: NextAuth.js v4 → Auth.js v5

    Esto tiene que quedar claro: el ecosistema está en movimiento. NextAuth.js está evolucionando hacia Auth.js (v5). ¿Por qué? Porque no quieren quedarse atados solo a Next.js. Quieren que funcione también en otros frameworks: SvelteKit, SolidStart, Express…
    ¿Qué implica esto para ti?
    • Nueva API unificada. Más poderosa, mejor integración con Server Actions y App Router.
    • Documentación en proceso. La v5 ha estado en beta y la documentación todavía se alinea.
    • Si arrancas un proyecto con Next.js 14 o superior: técnica y pragmáticamente, empieza con v5. Evitarás dolores de migración.
    Sí, duelen las beta-docs. Pero es mejor migrar ahora que rehacerlo todo después.

    Un ejemplo real y útil (sin poesía)

    Piensa en un componente servidor que solo debe ver el usuario autenticado. Con Auth.js/NextAuth puedes validar en el servidor antes de renderizar: 
    import { auth } from "@/auth"
import { redirect } from "next/navigation"

export default async function Dashboard() {
  const session = await auth()
  if (!session) redirect("/login")
  return <h1>Panel seguro de {session.user.name}</h1>
}
    Eso no es ciencia ficción. Es práctica común. Y evita que la UI se entere antes que el servidor. La seguridad no depende del cliente.

    El dev escéptico y su evolución

    Conozco al dev escéptico. Le encanta escribir autenticaciones a mano. Cree que es más “limpio”. Tres meses después, está leyendo logs a las 3 a.m. por un problema de sesiones. Cambió. Aprendió. No renunció a la personalización: NextAuth.js ofrece callbacks, eventos y handlers. Puedes seguir siendo “muy tuyo” sin pagar el precio de hacerlo todo desde cero.

    Cuando no deberías usar NextAuth.js

    No todo es para todos. Elige otra cosa si:
    • Necesitas SAML/SSO empresarial complejo con flujos B2B avanzados.
    • Quieres una consola de usuarios y control RBAC administrada por un tercero (Clerk, Auth0 lo hacen).
    • Tu equipo no quiere tocar la infraestructura de usuarios y prefiere externalizarlo.
    Si la respuesta es “no me complico la vida” y estás dispuesto a pagar por eso, un SaaS puede ser mejor.

    Migración y estrategia práctica

    Si ya tienes autenticación casera, ¿migrar? Hazlo por fases:
    • Analiza qué needs tienes: invalidación en tiempo real, multi-provider, passwordless.
    • Implementa NextAuth.js en modo JWT en staging. Observa.
    • Si necesitas revocar sesiones pronto, añade el adapter y cambia a sesiones en DB.
    • Aprovecha callbacks para mapear datos de usuario sin romper tus modelos.
    No es tan doloroso. Pero exige disciplina.

    Pequeñas trampas que nadie te cuenta

    • No uses credentials si no entiendes hashing y políticas de seguridad.
    • Validar en cliente es mala idea. Siempre valida en servidor.
    • Documentación: si empiezas con v5, sigue la docs oficiales y ejemplos; ignora tutoriales viejos de v4.
    • Cookies seguras: en producción siempre en https y withSameSite apropiado.

    Metáfora útil (porque la mente recuerda imágenes)

    NextAuth.js es el portero de tu club. No decide a quién gustas. Solo asegura que el que entra esté autorizado. El portero no es el dueño del club, pero conoce la lista, sabe cuándo pedir identificación y tiene la potestad de sacar a cualquiera que cause problemas.

    Urgencia realista

    Si estás empezando un proyecto con Next.js 14+:
    • Empieza con Auth.js (v5).
    • Si pospones, la migración será más cara dentro de 6-12 meses.
    • No por FOMO, sino por coherencia técnica.

    CTA simple y sin vueltas

    ¿Quieres un setup funcional en 10 minutos? Haz esto: instala next-auth o auth y sigue la guía oficial para tu provider preferido. ¿Quieres que te lo arme paso a paso? Respóndeme este mensaje y te doy una checklist práctica y un ejemplo listo para copiar y pegar.

    Esto no acaba aquí

    Autenticación es una zona de fricción constante. Cambian las APIs, aparecen runtimes Edge, el usuario espera menos fricción y más seguridad. NextAuth.js te da una base sólida. Pero ninguna herramienta es el final de tu trabajo. Es la primera línea del plan.
    Si quieres, la próxima entrega la dedicamos a:
    • Migración completa v4 → v5.
    • Ejemplos avanzados con adapters (Prisma, Supabase).
    • Estrategias para invalidación instantánea y refresh tokens.
    ¿Quieres que sigamos? Respóndeme. No es una promesa vacía: es la continuación que necesitas para no aprender las cosas a las malas.

    FAQ

    ¿Qué es NextAuth.js / Auth.js?

    NextAuth.js es una solución de autenticación open source creada para Next.js; Auth.js (v5) es la evolución que amplía soporte a otros frameworks. Proporcionan manejo de sesiones, providers OAuth, magic links y adapters para DB/ORMs.

    ¿Cuándo usar JWT vs sesiones en BD?

    Usa JWT si priorizas performance y quieres evitar consultas a la DB por petición. Usa sesiones en BD si necesitas revocar accesos en tiempo real y tener control inmediato sobre sesiones.

    ¿Puedo manejar credenciales con NextAuth.js?

    Sí, existe el proveedor de “credentials”, pero no es recomendado si no controlas hashing, salting, políticas y protección frente a fuerza bruta. Además, usar credentials suele forzar sesiones en JWT y desactivar sesiones en BD.

    ¿Auth.js v5 es estable para nuevos proyectos?

    La v5 ha estado en beta y la documentación aún se alinea. Sin embargo, si arrancas con Next.js 14+, técnica y pragmáticamente conviene empezar con v5 para evitar migraciones futuras.

    ¿Cómo validar sesiones en servidor con App Router?

    Puedes llamar a la utilidad de autenticación en componentes servidor antes de renderizar. Ejemplo: llamar a auth() y redirigir si no hay sesión para evitar exponer rutas desde el cliente.

    ¿Qué proveedores soporta?

    Soporta múltiples providers OAuth como Google, GitHub, Apple, Discord, además de magic links y adapters para Prisma, Drizzle, Mongo, Supabase, entre otros.

    ¿Qué debo evitar al implementar autenticación?

    No uses credenciales si no entiendes seguridad de contraseñas. No confíes en validación en cliente. Asegura cookies en producción (https, SameSite). Sigue la documentación actual de la versión que eliges y evita tutoriales desactualizados.
  • Dominando Claude Code como agente CLI para automatización efectiva

    Dominando Claude Code como agente CLI para automatización efectiva

    Claude Code – La guía práctica: Ingeniería de agentes en la terminal

    Tiempo estimado de lectura: 4 min

    • Claude Code es un agente CLI que lee árbol de archivos, ejecuta bash, corre tests y propone parches; requiere sandboxes y gobernanza técnica.
    • Controla tokens y contexto desde el día 1 usando comandos operativos como /cost, /compact y flags como --safe.
    • Define prompts como contratos con contexto, tarea, restricciones, verificación y condición de parada para evitar bucles.
    • Extiende de forma segura con MCP y orquesta validaciones con n8n; nunca expongas credenciales y aísla ejecuciones en contenedores.
    • Aplica políticas de seguridad, revisión humana obligatoria y auditoría de logs antes de producción.

    Claude Code – La guía práctica es el manual operativo que necesitas si tu equipo va a delegar trabajo real en un agente CLI. Claude Code (Claude 3.7 Sonnet) no es un autocompletador: es un agente que lee el árbol de archivos, ejecuta bash, corre tests y propone parches. Dominarlo exige reglas claras, sandboxes y gobernanza técnica.

    Resumen rápido (lectores con prisa)

    Claude Code es un agente CLI capaz de operar sobre repositorios (leer archivos, ejecutar comandos, proponer parches). Úsalo con sandboxes (Docker/DevContainers), define prompts como contratos y controla costes con comandos como /cost. Extiende funciones con MCP y orquesta validaciones con n8n, manteniendo revisión humana para cambios sensibles.

    Claude Code – La guía práctica: qué aprender primero

    Arranca por lo esencial. La documentación oficial y el MCP son la base:

    Instalación básica

    Instalación global con npm:

    npm install -g @anthropic-ai/claude-code

    Crea un .claudeignore en la raíz para proteger secretos:

    .env*
node_modules/
dist/
secrets/
*.log

    Lee “Permissions and Security” en la docs antes de ejecutar en repos real. No es opcional.

    Fundamentos operativos: control de contexto y coste

    Claude Code consume tokens por lectura/escritura. Controla eso desde el día 1.

    Operaciones y flags

    • /cost — audita tokens de la sesión. Obliga a revisar antes de tareas largas.
    • /compact — comprime historial de conversación para evitar alucinaciones si el agente lleva horas iterando.
    • /abort — detiene loops. Úsalo rápido si ves repetición.
    • Flags: --safe (revisar comandos propuestos), --read-only (auditoría sin mutar), --detach (tareas largas en background).

    Estos comandos son tus palancas operativas para no perder control.

    Ingeniería de prompts y contratos de ejecución

    Un prompt es un contrato, no un deseo. Estructura clara:

    • Contexto (stack, convenciones).
    • Tarea (qué cambiar).
    • Restricciones (qué no tocar).
    • Verificación (tests, coverage, linter).
    • Condición de parada (máx iteraciones).

    Ejemplo compactado

    Contexto: Angular 22 Zoneless.
Tarea: Migrar src/dashboard a Standalone Components usando Signals.
Restricciones: No tocar auth-service.
Verificación: Ejecutar `vitest --coverage` y superar 90%.
Parada: Abortar si >3 iteraciones fallidas.

    Sin eso, el agente entra en bucles y consume tokens sin producir valor.

    Extensibilidad: MCP y orquestación con n8n

    MCP te permite dar herramientas seguras al agente. Monta un servidor MCP interno y expón solo capacidades limitadas (leer DB, disparar webhooks), nunca credenciales.

    Ejemplo conceptual de servidor MCP (Node.js)

    // mcp-server.js (conceptual)
const { createServer } = require('mcp');
const server = createServer({
  capabilities: {
    read_file: true,
    execute_shell: { shell: 'bash', workingDir: '/workspace' },
    trigger_n8n: { url: 'http://localhost:5678/webhook' }
  }
});
server.listen(8080);

    Integra con Claude Code: /mcp add --url http://localhost:8080.

    Flujo n8n recomendado

    1. Claude genera diff + artefactos.
    2. MCP envia payload a n8n.
    3. n8n ejecuta validaciones (linters, tests), crea ticket y notifica Slack.

    Así mantienes trazabilidad y control humano.

    Seguridad y sandboxing: reglas innegociables

    • Nunca ejecutes tareas destructivas en la host machine. Usa Docker/DevContainers.
    • .claudeignore obligatorio y auditado por SAST.
    • Políticas de gasto: quotas por usuario/equipo en Anthropic Console.
    • Revisión humana obligatoria para cambios que modifiquen infra o credenciales.
    • Logs y auditoría: guarda transcripts de sesiones y resultados de /cost.

    Riesgos comunes y mitigaciones rápidas

    • Bucles por flaky tests → define max_iterations en prompt; usa --safe.
    • Consumo inesperado de tokens → descompón tareas; monitoriza /cost.
    • Fuga de secretos → .claudeignore + escaneo pre-run.
    • Dependencias legacy (p. ej. zone.js en Angular) → audita npm ls previo y fija tests que cubran edge cases.

    Cuándo adoptarlo (criterio para Tech Leads)

    Adopta Claude Code si:

    • Tienes stack moderno (TypeScript, Angular 22+, Next.js).
    • La base tiene tests automáticos (Vitest/Playwright).
    • Puedes aislar ejecuciones en contenedores y aplicar políticas de gasto.

    Pospón si:

    • Repo monolítico sin cobertura.
    • Equipo sin habilidades de prompt engineering.
    • Restricciones presupuestarias que no toleran picos de tokens.

    Roadmap práctico (4 semanas)

    • Semana 1: Sandbox + --safe, .claudeignore, métricas /cost.
    • Semana 2: Prompts estructurados y pruebas automáticas con Vitest.
    • Semana 3: Implementa servidor MCP mínimo y flujo n8n.
    • Semana 4: Políticas de gobernanza, cuotas, playbook de incidentes.

    Claude Code no es magia; es ingeniería aplicada. Monta sandbox, define contratos de prompts, limita el alcance con MCP y registra todo. Hazlo bien y convertirás la terminal en un colaborador que acelera refactors y tareas repetitivas sin apagar el control humano. Esto empieza hoy: configura el sandbox y documenta las reglas internas; el resto viene después.

    Dominicode Labs

    Para equipos que diseñan flujos de automatización y orquestación con agentes, una fuente útil de referencia y experimentación es Dominicode Labs. Puede servir como continuación lógica para prototipar MCP + n8n y playbooks de gobernanza.

    Referencias y recursos

    FAQ

    ¿Qué es Claude Code y en qué se diferencia de un autocompletador?

    Claude Code es un agente CLI que puede leer el árbol de archivos, ejecutar comandos de shell, correr tests y proponer parches. No es solo un autocompletador: realiza acciones sobre el repositorio y requiere control operativo y políticas de seguridad.

    ¿Cómo evito que el agente consuma tokens excesivos?

    Monitorea con /cost, descompón tareas largas, establece max_iterations en prompts y usa /compact para reducir historial. Usa flags como --safe para revisar comandos propuestos.

    ¿Qué medidas de seguridad son obligatorias antes de ejecutar en repos reales?

    Usar sandboxes (Docker/DevContainers), tener .claudeignore auditado por SAST, cuotas en Anthropic Console y revisión humana para cambios que modifiquen infra o credenciales.

    ¿Qué es MCP y por qué usarlo?

    MCP (Model Context Protocol) permite exponer capacidades limitadas y seguras al agente (leer archivos, ejecutar shell controlado, disparar webhooks) sin revelar credenciales. Facilita gobernanza y trazabilidad.

    ¿Cuándo debo usar --safe o --read-only?

    Usa --safe para revisar comandos propuestos por el agente en tareas de riesgo, y --read-only para auditorías o análisis sin mutar el repositorio.

    ¿Cómo integro validaciones automáticas con n8n?

    Configura MCP para enviar payloads a n8n; n8n ejecuta linters y tests, crea tickets y notifica Slack. El flujo recomendado: Claude genera diff, MCP envía a n8n, n8n valida y crea trazabilidad.

    ¿Qué debe incluir un prompt para evitar bucles?

    Un prompt debe contener: contexto (stack), tarea específica, restricciones explícitas, criterios de verificación (tests, coverage) y condición de parada (máx iteraciones).

  • 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.