DOMINICODE

Category: AI

  • Cómo implementar Spec Driven Development para APIs efectivas

    Cómo implementar Spec Driven Development para APIs efectivas

    qué es el sdd spec driven develoment ?

    Tiempo estimado de lectura: 3 min

    • Ideas clave:
    • Escribe la especificación antes del código: la spec es la fuente de verdad.
    • Mockea y genera clientes para trabajar en paralelo entre frontend y backend.
    • Añade contract tests en CI: si la implementación rompe la spec, el despliegue falla.
    • SDD reduce errores de integración y facilita integraciones con agentes/LLMs.

    Introducción

    Si odias las reuniones de “la API cambió, rompe todo” y quieres que tu equipo deje de jugar al teléfono roto entre frontend y backend, necesitas entender qué es el SDD (Spec Driven Development). En la práctica: escribes la especificación antes de tocar el código y conviertes la API en un contrato inmutable que todos cumplen.

    Esto no es dogma académico. Es la forma de eliminar bloqueos, acelerar paralelismo y hacer que tus integraciones sean predecibles. Y sí: funciona con agentes de IA, n8n y cualquier cosa que consuma tu API.

    Resumen rápido (lectores con prisa)

    SDD: la spec (OpenAPI/AsyncAPI/GraphQL Schema) es la fuente de verdad. Se diseña primero, se mockea, se generan SDKs y se prueban contratos en CI. Mejora paralelo frontend/backend y reduce errores de integración.

    qué es el sdd spec driven develoment ? — la definición práctica

    SDD es una disciplina donde la especificación (OpenAPI, AsyncAPI o un Schema GraphQL) es la fuente de verdad. No es “documentación”, es contrato ejecutable. Se diseña primero, se mockea al instante, se generan SDKs y se prueba que la implementación respete el contrato.

    Diferencia clave: en Code-First la verdad vive en el código. En SDD la verdad vive en un YAML/JSON que describe rutas, parámetros, tipos y respuestas. Punto.

    Por qué importa (y rápido)

    • Frontend y backend trabajan en paralelo sin adivinar.
    • Reduces bugs por cambios inesperados.
    • Ganas velocidad en onboarding: un dev nuevo lee la spec y ya sabe qué consumir.
    • Facilitas integraciones con agentes/LLMs que necesitan “leer” tu API (OpenAI Functions, LangChain).

    Referencias útiles: OpenAPI, Stoplight.

    Workflow mínimo para empezar con SDD

    1. Define openapi.yaml con endpoints y schemas.
    2. Levanta un mock (Prism) y deja que el frontend consuma datos “reales”.
    3. Genera clientes tipados y validadores.
    4. Implementa backend y añade Contract Tests en CI.
    5. CI/CD falla si la implementación no cumple la spec.

    Ejemplo rápido: generar cliente TS desde un spec

    npx @openapitools/openapi-generator-cli generate \
  -i ./openapi.yaml -g typescript-axios -o ./src/api-client

    Herramientas prácticas

    Un ejemplo concreto que duele menos

    Tienes un endpoint /orders/{id}. En el YAML defines exactamente:

    • Qué headers acepta.
    • Qué campos estarán en 200 y en 404.
    • Qué errores normalizarás (codes y body).

    Con eso:

    • Frontend crea UI y pruebas contra el mock.
    • Backend implementa y corre Pact en CI.
    • Si el backend devuelve un campo distinto, CI falla y el deploy no sale.

    Sí, suena estricto. Funciona.

    SDD y agentes de IA: por qué es crítico ahora

    LLMs tienden a “alucinar” cuando no saben cómo interactuar con una API. Darles un OpenAPI bien formado reduce ese ruido: el agente sabe rutas, cuerpos y respuestas válidas. Si estás integrando GPT con funciones o construyendo agentes que llaman tus servicios, SDD no es una sugerencia; es requisito.

    Contraindicaciones reales

    • Prototipos de 1-2 días o hackathons: overhead inútil.
    • Solopreneurs que iteran a ciegas: agilidad pura puede ser más valiosa.

    La regla práctica: si tu API tiene más de dos consumidores (frontends, microservicios, terceros), SDD paga su coste en la primera iteración.

    Cómo empezar hoy (lista corta y accionable)

    1. Crea openapi.yaml en un repo /api-specs.
    2. Añade Spectral como pre-commit para validar la spec.
    3. Levanta Prism: npx @stoplight/prism@latest mock ./api-specs/openapi.yaml
    4. Genera cliente TS: ver comando arriba.
    5. Integra Pact/Dredd en CI para contract testing.

    Conclusión — qué esperar después de implementar SDD

    Implementar SDD cambia el ritmo: menos incendios en integración, más trabajo paralelo y APIs que se comportan como contratos. No es mágia gratis: exige disciplina y revisión del contrato antes del código. Pero si tu equipo quiere escalar con confianza, SDD convierte el caos en previsibilidad.

    Haz esto ahora: define un endpoint crítico con OpenAPI, levanta un mock y obliga al frontend a usarlo dos días. Verás la diferencia en productividad y llamadas de emergencia. No es el final del camino — es el comienzo de un ciclo de despliegues confiable.

    Para recursos y experimentos con agentes y workflows, visita Dominicode Labs. Es una continuación natural si estás aplicando SDD a integraciones con IA y automatizaciones.

    FAQ

     

    ¿Qué es SDD?

    SDD (Spec Driven Development) es una disciplina donde la especificación (OpenAPI, AsyncAPI o un Schema GraphQL) es la fuente de verdad. Se diseña primero, se mockea, se generan SDKs y se prueban contratos para asegurar que la implementación respeta la spec.

    ¿Cuándo no conviene usar SDD?

    No es recomendable para prototipos de 1-2 días o hackathons por el overhead. Tampoco suele encajar para solopreneurs que priorizan iteración rápida sobre contratos estrictos.

    ¿Cómo empiezo hoy con SDD?

    Crea openapi.yaml en un repo /api-specs, añade Spectral como pre-commit, levanta Prism con npx @stoplight/prism@latest mock ./api-specs/openapi.yaml, genera cliente TS y añade Pact/Dredd en CI.

    ¿Qué herramientas recomiendan para mocking y lint?

    Para mocking se recomienda Prism. Para lint y reglas de spec se recomienda Spectral.

    ¿Cómo ayuda SDD con agentes de IA?

    Un OpenAPI bien formado reduce “alucinaciones” al dar a los agentes información precisa de rutas, cuerpos y respuestas válidas, lo que es crítico para integraciones con GPT, OpenAI Functions y agentes que llaman servicios.

    ¿Qué ocurre si la implementación no cumple la spec?

    Si la implementación no cumple la spec, los contract tests en CI hacen que CI/CD falle y el deploy no se realice hasta corregir la divergencia.

  • Cómo montar un workflow real con n8n + IA para clasificar y responder emails

    Cómo montar un workflow real con n8n + IA para clasificar y responder emails

    Tiempo estimado de lectura: 6 min

    • Ideas clave:
    • Diseñar un workflow en n8n con separación de responsabilidades: trigger, clasificación, routing, generación y creación de borradores.
    • Usar modelos distintos según la tarea: modelo económico para clasificación (gpt-4o-mini) y modelo de mayor calidad para generación (gpt-4o).
    • Mantener control humano creando borradores y aplicando validaciones, logs y métricas.

    Introducción

    Cómo montar un workflow real con n8n + IA para clasificar y responder emails — ese es el objetivo aquí. En las primeras líneas: vamos a construir un flujo operable en producción que no solo responda, sino que entienda intención, extraiga datos clave y deje al humano en control mediante borradores. No es magia; es arquitectura.

    Resumen rápido (lectores con prisa)

    Diseño de workflow en 5 bloques: Trigger (captura), Clasificador (LLM -> JSON), Router (Switch por categoría/ confianza), Generador (LLM de alta calidad) y Acción segura (crear borrador). Usa modelos separados para coste/latencia y mantiene control humano con borradores y métricas.

    Arquitectura minimal y responsabilidades

    Antes de tocar nodos, entiende el mapa. Cinco bloques claros:

    • Trigger — detectar nuevos correos (Gmail/IMAP).
    • Clasificador — LLM que devuelve JSON estructurado con categoría, confianza y resumen.
    • Router — lógica condicional (Switch) que dirige a ramas: sales, support, spam, urgent.
    • Generador — LLM de mayor calidad que redacta la respuesta contextual.
    • Acción segura — crear borrador en Gmail/Outlook para revisión humana.

    Este diseño separa decisiones y permite métricas y fallbacks.

    Requisitos y enlaces útiles

    Prepara clave API de OpenAI y credenciales OAuth para Gmail/IMAP.

    Paso a paso: Cómo montar un workflow real con n8n + IA para clasificar y responder emails

    A continuación, la implementación práctica y reproducible.

    Paso 1 — Trigger: captura segura

    – Nodo: Gmail Trigger (Message Received) o IMAP Trigger.
    – Filtros: Label = INBOX, Read Status = Unread.
    – Excluir: no-reply@*, tu propio dominio, newsletters. Evita bucles de autorespuesta.

    Configuración correcta aquí evita duplicados y ruido.

    Paso 2 — Clasificación semántica con LLM

    – Nodo: OpenAI Chat Model.
    – Modelo recomendado: gpt-4o-mini para clasificación (rápido y económico).
    – Response Format: JSON Object.

    System Prompt (ejemplo, copia y adapta):

    Eres un triador de emails. Devuelve SOLO un JSON con este esquema:
{
  "category": "support|sales|billing|urgent|spam|other",
  "confidence": 0.0-1.0,
  "summary": "una frase",
  "sentiment": "positive|negative|neutral",
  "entities": {"contactName":"", "companyName":""},
  "requires_human": true|false
}

    User Prompt: pasa {{ $json["text"] }} o {{ $json["snippet"] }} desde Gmail Trigger.

    Paso 3 — Parseo y routing

    – Usa un nodo Code / Set para parsear la salida JSON (si es necesario).
    – Nodo Switch: condiciones sobre category y confidence.

    • urgent → alerta Slack/PagerDuty.
    • sales → rama generador ventas.
    • spam & confidence > 0.95 → archivar/label.
    • default → crear borrador (human in loop).

    Paso 4 — Generación de la respuesta

    – Nodo: OpenAI Chat Model. Modelo: gpt-4o (mejor calidad para copy).
    – System Prompt específico por rama. Ejemplo (ventas):

    Eres un SDR. Objetivo: agendar 15 min. Tono: profesional/cercano. No inventes precios.

    – Incluye contexto: correo original + FAQ o snippets relevantes (puedes hacer RAG conectando Pinecone/Vector DB si necesitas datos internos).

    Paso 5 — Human‑in‑the‑loop: crear borrador en Gmail

    – Nodo Gmail: Action = Create Draft.
    – To: remitente original. Subject: Re: {{ $json.subject }}. Body: {{ $json.generated_response }}.
    Nunca envíes automáticamente hasta validar en producción.

    Operacional: métricas, costes y escalado

    – Métricas: tasa de clasificación correcta, time‑to‑draft, % borradores enviados. Guarda logs en Supabase/Postgres.
    – Costes: ejemplo aproximado (1.000 emails/mes): clasificación con gpt-4o-mini y 500 respuestas en gpt-4o → coste bajo (USD variable según precios). Mide y ajusta modelo por SLA.
    – Escalado: para >100 ejecuciones/h configura workers en n8n y monitoriza latencias. Guía: https://docs.n8n.io/hosting/scaling/worker-setup/

    Robustez y seguridad

    • Validación: siempre valida que la salida JSON cumple el esquema antes de usarla.
    • Retries y dead‑letter queue: implementa reintentos y guarda fallos en una tabla para revisión.
    • Privacidad: no pongas datos sensibles en prompts sin manejo de PII; usa hashing o anónimos si procede.
    • Auditoría: guarda prompt + response para facilitar tuning y control de calidad.

    Extensiones prácticas (pasos siguientes)

    • Añadir RAG: vector DB (Pinecone/Qdrant) para respuestas precisas desde docs internas.
    • Automatizar tickets: Convertir ramas “support” en tickets Jira/Asana.
    • Feedback loop: usa los borradores enviados (o las ediciones humanas) para etiquetar y mejorar prompts.

    Recursos y ejemplos listos

    Implementa esta base en staging con 5–20 correos reales, afina prompts y reglas, y solo entonces escala. Un workflow así reduce tiempo por correo de minutos a segundos, pero mantiene control humano: esa es la diferencia entre automatización amateur y sistema de producción.

    Para más experimentación y prototipos visita Dominicode Labs. Aquí puedes encontrar recursos complementarios y ejemplos para extender workflows con RAG, integraciones y pipelines de datos.

    FAQ

     

    1. ¿Qué nodos de trigger debería usar?

    Usa Gmail Trigger (Message Received) si trabajas con Gmail y necesitas webhooks/OAuth; usa IMAP Trigger si trabajas con otros proveedores o prefieres conexión IMAP. Filtra por label INBOX y unread.

     

    2. ¿Qué modelo usar para clasificación vs generación?

    Para clasificación usa gpt-4o-mini por coste y latencia. Para generación de copy y respuestas contextuales usa gpt-4o u otro modelo de mayor calidad.

     

    3. ¿Cómo evito bucles de autorespuesta?

    Excluye remitentes como no-reply@*, tu propio dominio y newsletters. Añade reglas en trigger y un header/custom label para detectar respuestas generadas por el sistema.

     

    4. ¿Qué validar antes de crear un borrador?

    Valida que el JSON devuelto cumple el esquema, que la confianza es adecuada (por ejemplo >0.6 para automatizaciones suaves) y que no hay PII sensible sin anonimizar.

     

    5. ¿Cómo medir coste y rendimiento?

    Mide tokens por llamada, número de llamadas por email, ratio de borradores aceptados/editar, latencia por nodo y coste por 1.000 emails. Guarda métricas en una DB como Supabase/Postgres.

     

    6. ¿Cómo integrar RAG para respuestas precisas?

    Indexa docs internos en un vector DB (Pinecone/Qdrant). Al generar la respuesta, recupera snippets relevantes y pásalos como contexto al modelo para reducir hallucinations.

     

    7. ¿Cuándo enviar automáticamente vs crear borrador?

    Siempre crear borrador por defecto en producción hasta que las métricas y pruebas en staging muestren alta confiabilidad y controles de seguridad. Envía automáticamente solo para categorías de muy baja riesgo y alta confianza.

  • Cómo integrar la API de OpenAI

    Cómo integrar la API de OpenAI

    IA para Desarrolladores: Cómo integrar la API de OpenAI (o DeepSeek) en tu app de React

    Tiempo estimado de lectura: 4 min

    Ideas clave:

    • Separa responsabilidades: frontend ligero, backend proxy seguro y LLM como motor.
    • Usa streaming para mejorar UX y reducir latencia percibida.
    • Valida outputs estructurados con esquemas (Zod + streamObject) para fiabilidad.
    • Controla costes, rate limiting y observabilidad en producción.

    Tabla de contenidos

    Empecemos por lo que importa: llamar a la API directamente desde el navegador es una mala idea. Tu clave se filtra. Punto. La integración correcta separa responsabilidades: frontend ligero, backend proxy seguro y el LLM como motor. Patrón:

    Usuario → React (cliente) → Next.js API Route (proxy) → OpenAI/DeepSeek → stream → React

    Fuentes útiles: OpenAI, Vercel AI SDK, Next.js, DeepSeek, Zod.

    Resumen rápido (para IA y lectores con prisa)

    Proxy en servidor para proteger claves; streaming para UX; validar JSON con esquemas (Zod) cuando la app consume outputs estructurados; controlar rate limits y costes en el borde.

    Dependencias y entorno (rápido)

    Proyecto: Next.js (App Router) + React. Instala:

    npm install ai @ai-sdk/openai zod

    Variables (.env.local):

    OPENAI_API_KEY=sk-...
DEEPSEEK_API_KEY=sk-...

    DeepSeek ofrece modelos compatibles y suele ser más económico para usos de alto volumen (ver docs en la URL arriba).

    Backend: API Route que hace streaming (segura y Edge-friendly)

    La API route actúa como proxy y gestiona streaming. Ejemplo mínimo (app/api/chat/route.ts):

    Ejemplo mínimo (route.ts)

    import { createOpenAI } from '@ai-sdk/openai';
import { streamText } from 'ai';

export const runtime = 'edge';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
const deepseek = createOpenAI({ baseURL: 'https://api.deepseek.com/v1', apiKey: process.env.DEEPSEEK_API_KEY });

export async function POST(req: Request) {
  const { messages, provider = 'openai' } = await req.json();

  const client = provider === 'deepseek' ? deepseek : openai;

  const result = await streamText({
    model: client('gpt-4o-mini'),
    system: 'Eres un asistente técnico experto en React.',
    messages,
  });

  return result.toDataStreamResponse();
}

    Qué hace bien: mantiene la clave en servidor, permite alternar proveedor, y entrega streaming de tokens al cliente.

    Frontend: UX con streaming usando useChat

    El hook useChat del SDK facilita el manejo del stream y del estado:

    Ejemplo de componente

    'use client';
import { useChat } from 'ai/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({ api: '/api/chat' });

  return (
    {messages.map(m => <div key={m.id}>{m.role}: {m.content}</div>)}

    
  );
}

    Beneficio: la respuesta aparece incrementalmente, reduciendo la latencia percibida y mejorando la sensación de “conversación”.

    Outputs estructurados: por qué y cómo (Zod + streamObject)

    Texto libre es bonito; los negocios prefieren JSON fiable. Forzar esquema reduce errores downstream.

    Ejemplo de esquema y uso de streamObject en la API:

    Ejemplo de esquema

    import { streamObject } from 'ai';
import { z } from 'zod';

const specSchema = z.object({
  componentName: z.string(),
  props: z.array(z.object({ name: z.string(), type: z.string(), required: z.boolean() })),
  description: z.string(),
});

const result = await streamObject({
  model: openai('gpt-4o-mini'),
  schema: specSchema,
  prompt: `Extrae el spec para un componente a partir de: "${prompt}"`,
});

    Resultado: JSON validado progresivamente. Útil para autocompletar formularios, pipelines ETL o alimentar otros microservicios.

    Producción: rate limit, coste, observabilidad

    – Rate limiting: imprescindible. Usa Upstash Redis (Upstash Redis) o Cloudflare Workers KV para bloquear abusos.

    – Costos: mide coste por petición. Usa modelos como gpt-4o-mini o DeepSeek para la mayoría de tareas; reserva modelos grandes para casos de alto valor.

    – Context window: implementa resumen o recorte de historial para no enviar todo el chat cada vez.

    – Caching: cachea respuestas determinísticas (resúmenes, clasificadores) en Redis.

    – Observabilidad: trackea latencia, tokens usados y errores con métricas (Prometheus/Datadog).

    Rate limiting

    Implementar límites por IP/usuario en el borde para evitar abusos y picos inesperados.

    Costos

    Monitoriza coste por petición y ajusta modelo según valor del caso de uso.

    Context window

    Usa resumenes o recortes de historial para mantener tokens bajo control.

    Caching

    Cachear respuestas determinísticas en Redis reduce coste y latencia.

    Observabilidad

    Mide latencia, tokens y errores con Prometheus o Datadog para depurar y optimizar.

    OpenAI vs DeepSeek — guía rápida

    – OpenAI: compatibilidad, calidad general, ecosistema maduro.

    – DeepSeek: compatibilidad API con OpenAI, coste por token mucho menor en muchos casos. Ideal para alto volumen.

    Elige según coste por consulta, SLA y privacidad de datos.

    Cuándo merece la pena añadir IA

    SÍ: clasificación automática, asistentes internos, resumir logs, prellenado de formularios, extracción de entidades.

    NO: lógica determinista sencilla, validaciones que no requieren lenguaje natural, funciones con requisitos de latencia extremo (<200ms).

    Cierre con utilidad real

    Integrar la API de OpenAI o DeepSeek en React no es solo pegar un fetch: es diseñar tubos de datos seguros, eficientes y observables. Implementa proxy, usa streaming para la UX, obliga esquemas cuando la app lo necesita y controla costes y abusos en el borde. En la próxima entrega te muestro cómo encadenar esto con n8n para automatizar workflows híbridos (IA + APIs externas). Apúntalo: la parte interesante empieza cuando la IA se convierte en parte del pipeline, no en el punto final.

    Para quien busque continuidad práctica en automatización y workflows con IA, puede explorar recursos adicionales en Dominicode Labs. Es una continuación lógica para pruebas y prototipos que combinan IA con pipelines y agentes externos.

    FAQ

    ¿Por qué no debo llamar a la API desde el navegador?

    Porque la clave de API se expone en el cliente y puede ser robada. Un proxy en servidor mantiene la clave segura y permite controlar acceso, logging y límites.

    ¿Qué ventajas tiene el streaming para la UX?

    El streaming entrega tokens incrementalmente, reduciendo la latencia percibida y mejorando la sensación de conversación. Es especialmente útil en asistentes interactivos.

    ¿Cómo aseguro que los outputs sean fiables para mi app?

    Forzando un esquema y validando el output (por ejemplo con Zod y streamObject). Esto reduce errores downstream y facilita integración con pipelines o formularios.

    ¿Cuándo usar DeepSeek en lugar de OpenAI?

    Cuando el coste por token y el volumen justifican una alternativa compatible. DeepSeek ofrece compatibilidad API con OpenAI y suele ser más económico en muchos casos.

    ¿Qué debo monitorizar en producción?

    Latencia, tokens usados por petición, tasa de errores y patrones de uso. Integra métricas en Prometheus o Datadog y registra costes por petición.

    ¿Cómo implemento rate limiting en el borde?

    Usa soluciones como Upstash Redis (Upstash Redis) o Cloudflare Workers KV para imponer límites por IP o por usuario y bloquear abusos.

  • Cómo crear aplicaciones full stack gratis con Antigravity para MVPs

    Cómo crear aplicaciones full stack gratis con Antigravity para MVPs

    Cómo crear aplicaciones full stack gratis con Antigravity (No Code)

    Tiempo estimado de lectura: 5 min

    Ideas clave

    • Prioriza el modelado de datos antes de la UI para evitar deuda inmediata.
    • Encapsula lógica de negocio en workflows; delega procesos pesados a webhooks cuando el plan gratuito limite.
    • Usa integraciones externas para archivos y tareas costosas para mantenerte en el tier gratuito.
    • Define criterios claros para migrar a código (tráfico, complejidad algorítmica, cumplimiento).

    Introducción

    Cómo crear aplicaciones full stack gratis con Antigravity (No Code) es una decisión de arquitectura, no un atajo. Si tu objetivo es validar una idea rápido, lanzar un MVP interno o iterar diseño de producto sin bloquear a Ingeniería, Antigravity te da el camino: editor visual, workflows y despliegue integrado. Aquí explico cómo hacerlo paso a paso, con buenas prácticas, límites del plan gratuito y criterios claros para migrar a código cuando toque.

    Resumen rápido (lectores con prisa)

    Antigravity es una plataforma visual que integra base de datos, workflows y frontend para prototipado rápido. Úsala para validar hipótesis, priorizando modelado de datos y encapsulando lógica en workflows; delega procesos pesados a webhooks o servicios externos cuando el plan gratuito sea limitante.

    Cómo crear aplicaciones full stack gratis con Antigravity (No Code): visión general

    Antigravity condensa frontend, backend y datos en un entorno visual. Técnicamente, reproduce las tres capas clásicas:

    • Base de datos visual (esquemas, relaciones).
    • Backend en forma de workflows y triggers.
    • Frontend con binding de datos y componentes drag‑and‑drop.

    No es magia: son abstracciones que generan código y artefactos exportables. La ventaja real es velocidad para prototipar y validar. El coste es control limitado sobre infra y escalado —pero si aplicas criterio, es una herramienta potente para MVPs.

    1) Empieza por los datos: modelado como prioridad

    No arranques por la UI. Diseña el modelo de datos primero.

    Pasos prácticos

    • Crea un proyecto y selecciona el plan Free/Starter.
    • En “Data” define tus tablas/colecciones. Ej.: Projects, Tasks, Users.
    • Tipifica campos (string, number, datetime, boolean). Evita usar campos libres cuando puedas normalizar.
    • Define relaciones (1:N, N:M) en la interfaz. Un Project tendrá muchas Tasks.
    • Planifica índices si Antigravity lo permite; si no, diseña consultas pensando en paginación.

    Por qué: una UI mal ligada a datos mal modelados genera deuda inmediata. Normaliza, evita duplicados y documenta el modelo.

    2) Construye la UI con binding de datos (no falsas promesas visuales)

    El editor visual es potente si respetas la separación de concerns.

    Recomendaciones

    • Usa componentes reutilizables: listas, formularios, cards.
    • Mapea cada componente a una fuente de datos (Data Source).
    • Mantén lógica de presentación fuera de la base de datos: usa campos calculados en la UI, no copias de datos.
    • Para estado local (por ejemplo selected_project_id) usa las herramientas de estado que ofrece la plataforma, no variables ad-hoc.

    Ejemplo

    Ejemplo: una lista de proyectos (componente “Repeating Group”) con binding al Projects y un evento que actualiza selected_project_id para filtrar Tasks.

    3) Workflows: la lógica de negocio sin servidor

    Los workflows reemplazan funciones server-side. Úsalos para lógica de negocio, integraciones y validaciones.

    Patrones prácticos

    • Trigger on event (click, submit, schedule).
    • Actions: create/update/delete, call external API, send email.
    • Condicionales: implementa reglas claras (ej. si amount > 1000 → marcar VIP).
    • Atomicidad: agrupa acciones que deban ejecutarse juntas y contempla rollback o compensación si la plataforma lo soporta.

    Si un workflow se hace demasiado complejo o consume muchas ejecuciones del plan gratuito, delega a un webhook y procesa fuera en una herramienta como n8n o un microservicio propio.

    4) Integraciones y almacenamiento eficiente (mantén lo gratis gratis)

    • Almacena archivos en Cloudinary o S3; guarda solo URLs.
    • Usa webhooks a n8n o servicios gratuitos para tareas pesadas (p. ej. generación de PDFs).
    • Aprovecha hosting gratuito: Netlify Drop o Firebase Spark para backends ligeros.

    Evita subir blobs o logs pesados a la base de datos de Antigravity: esos límites suben rápido.

    5) Seguridad, permisos y auditoría

    • Aplica principio de menor privilegio al habilitar conectores (Google Drive, Gmail).
    • Configura roles (admin, editor, reader) y controla qué workflows pueden leer/escribir datos sensibles.
    • Habilita logs y guarda evidence (diffs, screenshots) de despliegues si la plataforma lo ofrece.

    6) Criterio de migración: cuándo salir del No Code

    Antigravity acelera ideas, pero hay señales claras para migrar:

    • Tráfico real > 5–10k MAU o necesidades de performance específicas.
    • Lógica algorítmica compleja (simulaciones, ML, procesamiento batch).
    • Requisitos de compliance o auditoría estrictos.
    • Costes de vendor que, al escalar, superen el coste de reescribir en código.

    Plan mínimo de migración: exporta artefactos, documenta modelo de datos y workflows. Mueve a Next.js/Supabase o Next.js + Firebase según necesidades.

    Ejemplo rápido: MVP To‑Do con auth y deploy gratis

    1. Modelo: Users, Tasks (userId FK).
    2. UI: lista de tareas vinculada a Tasks y formulario para crear.
    3. Workflow: on submit → create Task → if due_date < ahora → mark urgent.
    4. Integración: autenticación con provider gratuito (si Antigravity ofrece, si no, usa Netlify Drop o Firebase o terceros como Clerk/Firebase).
    5. Deploy: usa el subdominio miapp.antigravity.app o export ZIP y deploy a Netlify Drop.

    Conclusión: Antigravity como acelerador de validación

    Cómo crear aplicaciones full stack gratis con Antigravity (No Code) es menos sobre evitar código y más sobre aplicar disciplina arquitectónica en un entorno visual. Prioriza datos, encapsula lógica en workflows bien pensados, delega procesos pesados a webhooks y controla permisos. Úsalo para validar hipótesis rápido; cuando el producto demuestre tracción, prepara la migración con la documentación que ya deberías haber generado.

    Recursos útiles

    Para continuidad y experimentación con workflows y automatizaciones relacionadas con los temas tratados (integraciones, webhooks y orquestación), considera explorar recursos adicionales y pruebas de concepto en Dominicode Labs como continuación lógica del enfoque aquí descrito.

    FAQ

    ¿Qué es Antigravity y para qué sirve?

    Antigravity es una plataforma visual que integra modelado de datos, workflows y un editor frontend para construir aplicaciones full stack sin escribir código. Sirve para prototipado rápido, MVPs y validación de ideas.

    ¿Por qué empezar por los datos?

    Porque un modelo de datos sólido evita deuda técnica, duplicados y problemas de integración con la UI. Diseñar esquemas y relaciones primero facilita consultas eficientes y mantenimiento.

    ¿Cuándo debo delegar un workflow a un webhook?

    Cuando la lógica sea demasiado compleja, consuma muchas ejecuciones del plan gratuito o requiera procesamiento pesado. En esos casos envía datos a un servicio externo (por ejemplo n8n) o un microservicio propio.

    ¿Cómo mantengo el proyecto en el plan gratuito?

    Almacena media en servicios externos (Cloudinary o S3), usa webhooks para tareas costosas y aprovecha hosting gratuito como Netlify Drop o Firebase Spark.

    ¿Qué incluye el plan mínimo de migración?

    Exporta artefactos, documenta el modelo de datos y workflows y selecciona destino (por ejemplo Next.js + Supabase o Next.js + Firebase). Prioriza migrar la lógica crítica y los datos exportables primero.

    ¿Qué herramientas externas recomiendan para almacenamiento y hosting?

    Para media: Cloudinary. Para workflows externos: n8n. Para hosting y deploy rápidos: Netlify Drop y Firebase.

  • 8 casos prácticos de uso de ChatGPT Agent para desarrolladores

    8 casos prácticos de uso de ChatGPT Agent para desarrolladores

    8 formas increíbles de usar ChatGPT Agent en 2026 (Modo Agente explicado)

    Tiempo estimado de lectura: 6 min

    • Ideas clave:
    • Un ChatGPT Agent es una arquitectura: LLM + herramientas + memoria + controlador de ejecución.
    • Casos prácticos incluyen productividad, investigación, presentaciones, finanzas, viajes, contenido, ventas y monitorización.
    • Diseño seguro y gobernanza (principio de menor privilegio, autenticación, observabilidad) son críticos.

    Introducción

    “8 formas increíbles de usar ChatGPT Agent en 2026 (Modo Agente explicado)” aparece aquí porque lo vamos a tratar con criterio técnico, no como hype. En 2026 un ChatGPT Agent deja de ser un “chat” y pasa a ser un ejecutor autónomo: recibe un objetivo, orquesta herramientas y entrega resultados reales.

    A continuación explico la arquitectura mínima, requisitos prácticos y ocho casos de uso aplicables a equipos de producto, devs y Tech Leads —con ejemplos accionables y riesgos técnicos que debes medir.

    Resumen rápido (lectores con prisa)

    Qué es: Un agente es un sistema compuesto por un LLM conectado a herramientas, memoria y un controlador de ejecución.

    Cuándo usarlo: Cuando necesites ejecutar objetivos autónomos que integren múltiples fuentes y acciones (investigación, automatización, monitorización).

    Por qué importa: Reduce semanas de trabajo a horas/minutos y habilita pipelines reproducibles.

    Cómo funciona: Ciclo plan→act→observar→corregir con herramientas externas y persistencia de estado.

    Qué es un ChatGPT Agent y cómo funciona técnicamente

    Un Agent = LLM + herramientas + memoria + controlador de ejecución.

    Componentes técnicos

    LLM

    LLM: GPT‑4o/o1 u otro modelo que razone en bucles.

    Herramientas

    Herramientas: navegador controlado, intérprete de Python, APIs (OpenAI Agents guide), n8n, Zapier.

    Memoria/estado

    Memoria/estado: persistencia de contexto y logs de acciones.

    Controlador

    Controlador: ciclo plan→act→observar→corregir (ReAct/OODA).

    Requisitos prácticos

    • Suscripción ChatGPT Plus/Team/Enterprise.
    • Conectores habilitados (Google Workspace, Zapier).
    • Permisos explícitos para ejecutar código y acceder a datos.
    • Documentación útil: OpenAI Agents guide, n8n, Zapier.

    Diseño seguro: permisos, auditoría y límites

    • Principio de menor privilegio: activa solo los conectores imprescindibles.
    • Autenticación: OAuth para Google APIs, claves rotadas para proveedores externos.
    • Observabilidad: logueo estructurado de acciones y outputs; guarda hashes de archivos generados.
    • Cuotas y rate limiting: controla llamadas a APIs para evitar costes descontrolados.

    Ocho casos prácticos

    Ahora sí: ocho casos prácticos, con foco en implementación real y valor medible.

    1. Productividad personal: briefing diario automatizado

    Objetivo: “Genera mi briefing diario a las 8:00 con acciones desde email y calendario.”

    Implementación:

    • Conector Gmail + Calendar.
    • Filtro por remitentes VIP y por reuniones con alta prioridad.
    • Salida: Markdown/Google Doc con 5 puntos accionables.

    Por qué funciona: reduce overhead de triage de correo y acelera decisiones del día.

    2. Investigación profunda: informe técnico en horas

    Objetivo: “Analiza adopción de WebAssembly en infra server-side y genera matriz de pros/cons.”

    Implementación:

    • Browser tool para GitHub, RFCs, blogs.
    • Intérprete Python para ejecutar pruebas ligeras (benchmarks de ejemplo).
    • Salida: PDF con referencias y tabla CSV.

    Valor: minutos en vez de días para hallazgos reproducibles.

    3. Presentaciones automáticas: PPTX con datos reales

    Objetivo: “Crea 12 slides sobre microfrontends, incluye diagramas y gráficos.”

    Implementación:

    • Generación de diagramas (Mermaid→SVG) y gráficas con Python (matplotlib/Plotly).
    • Librerías como python‑pptx para compilar .pptx.
    • Entrega lista para revisión, no diseño final.

    Beneficio: reduce 60–80% del tiempo de montaje de presentaciones técnicas.

    4. Finanzas: auditoría automática de P&L

    Objetivo: “Analiza CSV trimestral y detecta desviaciones >15%.”

    Implementación:

    • Pandas en el entorno del agente para limpieza y detección de outliers.
    • Export a Google Sheets + visualizaciones.

    Riesgo: validar transformaciones y contar con pruebas unitarias en scripts del agente.

    5. Viajes y logística: itinerarios optimizados

    Objetivo: “Planifica viaje devrel: costes, horarios y proximidad a venue.”

    Implementación:

    • APIs de vuelos/hoteles + Google Maps.
    • Generación de opciones A/B y calendario con enlaces de reserva.

    Útil para: equipos con viajes frecuentes y restricciones presupuestarias.

    6. Creación de contenido: pipeline editorial completo

    Objetivo: “Planifica y redacta 4 posts SEO sobre n8n para Q1.”

    Implementación:

    • API de keyword research + generación de outlines.
    • Borradores en Markdown y miniaturas generadas por modelo de imágenes.
    • Integración con CMS via Zapier/n8n.

    Escala: editorial sin multiplicar equipos.

    7. Outreach y ventas: SDR autónomo

    Objetivo: “Encuentra 10 fintechs España Serie A y redacta emails personalizados.”

    Implementación:

    • Data sources: Crunchbase/Dealroom + LinkedIn scraping controlado.
    • Plantillas personalizadas con variables extraídas.

    Cuidado legal: verifica términos de uso de fuentes y cumplimiento GDPR.

    8. Monitorización recurrente: vigía 24/7

    Objetivo: “Alertarme si aparece un piso 3 camas por debajo de X en barrio Y.”

    Implementación:

    • Búsquedas programadas, deduplicación y umbrales de notificación.
    • Notificaciones vía Slack/email solo si condicionales se cumplen.

    Resultado: alertas de alto valor, menos ruido.

    Limitaciones y métricas que importan

    • Coste por ejecución: controla llamadas a APIs y uso de cómputo.
    • Fiabilidad de datos externos: siempre valida con checkpoints humanos.
    • Métricas operativas: latencia de endpoints, tasa de éxito del workflow, número de correcciones humanas.

    Conclusión: pasar de promter a manager de objetivos

    ChatGPT Agent es arquitectura, no magia. Para sacarle partido necesitas objetivos claros, conectores bien gobernados y pipelines automatizados (n8n es un buen socio). Empieza por un caso pequeño (briefing o investigación). Implementa logs y validaciones. Y sí: esto no acaba aquí —en el próximo artículo mostraremos cómo integrar agentes con n8n y pruebas automatizadas para llevar estos flujos a producción.

    Dominicode Labs

    Si trabajas con automatización, agentes o workflows y quieres ejemplos reproductibles y patterns de ingeniería, echa un vistazo a Dominicode Labs. Es una continuación lógica para experimentar con pipelines y pruebas.

    FAQ

    ¿Qué es exactamente un ChatGPT Agent?

    Un Agent es una arquitectura compuesta por un LLM conectado a herramientas externas, memoria para persistir estado y un controlador que ejecuta ciclos de planificación y corrección.

    ¿Cuándo debería usar un agente en vez de un script programado?

    Usa un agente cuando el flujo requiere razonamiento iterativo, acceso a múltiples fuentes y la capacidad de corregir acciones en tiempo real. Para tareas deterministas y simples, un script puede ser suficiente.

    ¿Qué permisos requiere un agente para acceder a Google Workspace?

    Requiere OAuth con scopes mínimos necesarios (principio de menor privilegio). No des permisos de escritura si solo necesitas lectura.

    ¿Cómo audito las acciones de un agente?

    Registra logs estructurados de cada acción y su output, guarda hashes de archivos generados y conserva trazas del plan→act→observar→corregir.

    ¿Cuáles son los riesgos legales al usar scraping en flujos de outreach?

    Verifica términos de uso de las fuentes, respeta restricciones de scraping y considera cumplimiento GDPR cuando proceses datos personales.

    ¿Qué métricas operativas debo monitorizar?

    Latencia de endpoints, tasa de éxito del workflow, número de correcciones humanas y coste por ejecución.

  • Utiliza Gemini para Estrategias de Marketing Efectivas

    Utiliza Gemini para Estrategias de Marketing Efectivas

    Cómo puedo usar Gemini para marketing?

    Tiempo estimado de lectura: 6 min

    • Gemini como motor de tareas automatizadas en marketing.
    • Ventajas de contexto largo y multimodalidad nativa.
    • Casos de uso prácticos implementables.
    • Integración técnica a través de APIs y orquestación.
    • Costos y criterios para la elección de tareas a automatizar.

    Tabla de contenidos

    Qué hace distinto a Gemini (y por qué importa para marketing)

    Gemini combina tres ventajas relevantes para marketing técnico:

    • Ventana de contexto muy larga (hasta millones de tokens) que reduce la necesidad de chunking y RAG para datasets grandes.
    • Multimodalidad nativa: texto, imágenes, audio y video se procesan sin pasos intermedios.
    • Salidas estructuradas (JSON mode / function calling) que facilitan integración directa con sistemas.

    Fuentes oficiales: Google AI Studio y Vertex AI docs.

    Estas capacidades convierten a Gemini en un motor para tareas que antes requerían arquitectura compleja: auditorías de contenido masivo, análisis de VoC y generación de assets multimedia a escala.

    Tres casos de uso prácticos (implementables)

    1) Auditoría de contenido masiva

    Workflow: exporta tus últimos N artículos (HTML/PDF) → Request a Gemini con todo el corpus → salida en JSON con temas, gaps y enlaces rotos.

    Beneficio: detectas inconsistencias de tono y contenido redundante en una pasada, sin montar un vector DB. Ideal para calendarios editoriales y SEO técnico.

    2) Repurposing multimodal: video → artículos → social

    Workflow: subes un webinar (mp4) al endpoint de Gemini → pides timestamps, 3 insights técnicos y un hilo de Twitter + descripción YouTube optimizada.

    Beneficio: reduces coste y latencia de generar assets. Gemini “ve” diapositivas y transcribe/extrae contexto, creando versiones para distintos canales sin transcriptor externo.

    3) Personalización de outreach a escala (integrado con n8n)

    Arquitectura mínima:

    • Trigger: nuevo lead en CRM.
    • Enriquecimiento: scraping básico de la web del lead.
    • Gemini Flash: análisis rápido de la landing.
    • Gemini Pro: genera correo personalizado (JSON con asunto, body, 3 bullets técnicos).
    • n8n: orquesta revisión humana y envíos vía API de tu ESP.

    n8n: perfecto para orquestar sin reinventar la infraestructura. Usa nodos HTTP para llamar a Vertex AI o Google AI Studio.

    Cómo integrar técnicamente (API + orquestación)

    1. Registra proyecto en Google Cloud y usa Vertex AI o Google AI Studio.
    2. Usa SDKs oficiales (@google/genai) o llamadas REST a generativelanguage.googleapis.com.
    3. Diseña prompts con grounding: envía contexto estructurado (meta + fragmentos) y solicita JSON. Ejemplo de prompt: “Devuelve {subject, bullets[], cta} en JSON, respetando estos hechos: …”.

    Mini ejemplo JS (esqueleto):

    import { GoogleGenAI } from “@google/genai”;

    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_KEY });

    const resp = await ai.models.generateContent({ model: “gemini-2.5-flash”, contents: “…” });

    Para producción, añade retries, idempotency y límites de tokens.

    Costos, seguridad y criterios para elegir tareas a automatizar

    • Costos: usa modelos Flash/Lite para tareas de baja latencia; reserva Pro para razonamiento profundo. Mide tokens por flujo y calcula coste por lead.
    • Seguridad: revisa permisos OAuth, enmascara PII antes de enviar y habilita logging controlado en Vertex AI.
    • Criterio: automatiza tareas repetitivas y de alto volumen (análisis VoC, A/B copy generation, repurposing). No uses IA donde la verificación factual sea crítica sin human-in-the-loop.

    Dominicode Labs: de la prueba al sistema productivo

    Diseñar flows que integren Gemini, métricas y orquestación no es trivial. En Dominicode Labs construimos blueprints de n8n + Gemini que ya solucionan:

    • Ingestion de data (sitemaps, CSVs, videos).
    • Orquestación de prompts y validación humana.
    • Outputs estructurados listos para pipelines de marketing.

    Si tu objetivo es pasar de experimentos con prompts a sistemas repetibles y observables, Dominicode Labs ofrece templates y guías para acelerar esa transición sin vendor lock-in.

    Conclusión: usar Gemini para marketing con criterio

    Gemini no es un simple generador de textos; es una capa de razonamiento y procesamiento multimodal. Úsalo para: procesar grandes volúmenes de contenido, transformar multimedia en assets reutilizables y personalizar outreach mediante pipelines orquestados (n8n). El valor real aparece cuando la IA forma parte de una arquitectura medible: costos por token controlados, human-in-the-loop donde importa y observabilidad de resultados. Eso convierte experimentos en ventaja competitiva.

    FAQ

    ¿Qué es Gemini y cómo se diferencia de otros LLMs?

    Gemini es un modelo de lenguaje multimodal de Google que combina procesamiento de texto, imágenes, audio y video en un solo sistema, permitiendo integra contenido de manera más efectiva.

    ¿Cuál es el valor de usar Gemini en marketing?

    El valor radica en su capacidad para realizar tareas que típicamente requieren arquitecturas complejas, como auditorías masivas y generación de contenido multicanal a escala.

    ¿Cómo puedo iniciar con Gemini en mis proyectos?

    Puedes comenzar registrando un proyecto en Google Cloud, utilizando las APIs de Vertex AI o Google AI Studio, y aplicando los SDKs proporcionados.

    ¿Cuáles son las mejores prácticas para integrar Gemini?

    Diseña prompts claros que incluyan contexto estructurado, y asegúrate de añadir elementos de retry y control de tokens para mantener eficiencia y coste manejable.

    ¿Qué costos debo considerar al utilizar Gemini?

    Es importante evaluar la latencia de tareas, utilizando modelos adecuados para cada necesidad y controlando los tokens usados por lead para calcular costos eficaces.

  • Cómo Generar Clientes API con OpenAPI

    Cómo Generar Clientes API con OpenAPI

    Generación de clientes API OpenAPI para Angular

    La Generación de clientes API OpenAPI para Angular reduce la fricción entre frontend y backend convirtiendo la especificación OpenAPI en servicios, modelos y la capa de red completa de tu aplicación. Si la introducción no lo dice claro: genera el cliente, no copies interfaces a mano. Esto evita rupturas en runtime, recupera tipado estricto y convierte la API en la única fuente de verdad.

    Tiempo estimado de lectura: 4 min

    • Ideas clave:
    • Generar el cliente desde OpenAPI mantiene un tipado 100% fiel y reduce bugs por discrepancias entre equipos.
    • Usa herramientas maduras (OpenAPI Generator) para control a largo plazo; commitea el cliente generado y crea wrappers para extensiones.
    • Protege el contrato en CI: regenera y falla el pipeline si hay diffs.
    • Aplica patrones: base URL dinámica, interceptor para fechas y string enums para mejores tipos TS.

    Resumen rápido (lectores con prisa)

    Qué es: Producción automática de clientes TypeScript/Angular desde una spec OpenAPI.

    Cuándo usarlo: Siempre que frontend y backend evolucionen en paralelo y quieras una única fuente de verdad para la API.

    Por qué importa: Evita errores por desalineación, asegura tipado fiel y facilita detección temprana de breaking changes en CI.

    Cómo funciona: Una CLI genera modelos, servicios y módulos Angular a partir de un JSON/YAML OpenAPI; se integra con Dependency Injection y HttpClient.

    Generación de clientes API OpenAPI para Angular: por qué importa

    En equipos paralelos, el frontend comienza antes que el backend y viceversa. Sin una fuente de verdad única, los cambios sutiles (un campo renombrado, una paginación distinta) provocan bugs que no se detectan hasta producción.

    Beneficios técnicos

    • Tipado 100% fiel a la especificación.
    • Servicios Angular idiomáticos (HttpClient, DI).
    • Detección temprana de breaking changes en CI.
    • Menos boilerplate y menos deuda técnica.

    Fuentes útiles

    Herramientas recomendadas

    – OpenAPI Generator (recomendado para empresas): maduro, configurable y soportado por la comunidad.

    – ng-openapi-gen: más idiomático para Angular, menos configurable.

    – Orval: buena opción si trabajas multi-framework (React/Vue + Angular).

    Recomendación práctica: usa OpenAPI Generator si buscas control y estabilidad a largo plazo.

    Flujo mínimo práctico con OpenAPI Generator

    1. Exporta o publica tu spec en JSON/YAML (p. ej. /swagger.json).
    2. Añade la CLI como devDependency:
    npm install -D @openapitools/openapi-generator-cli

    3. Configura un archivo (infra-as-code), ejemplo openapitools.json:

    {
  "generator-cli": {
    "generators": {
      "v1": {
        "generatorName": "typescript-angular",
        "inputSpec": "api-specs/openapi.json",
        "output": "src/app/core/api/v1",
        "additionalProperties": {
          "ngVersion": "16.0",
          "fileNaming": "kebab-case",
          "stringEnums": true
        }
      }
    }
  }
}

    4. Añade script en package.json:

    "scripts": {
  "api:generate": "openapi-generator-cli generate"
}

    5. Ejecuta npm run api:generate. Resultado: src/app/core/api/v1 con models/, services/ y api.module.ts.

    Integración en Angular (ejemplo)

    Configura el módulo generado en tu AppModule/CoreModule:

    import { ApiModule, Configuration } from './core/api/v1';
@NgModule({
  imports: [
    ApiModule.forRoot(() => new Configuration({ basePath: environment.apiUrl }))
  ]
})
export class CoreModule {}

    Uso en componentes (inyección del servicio generado):

    constructor(private usersService: UsersService) {}
ngOnInit() {
  this.usersService.getUsers().subscribe(users => this.users = users);
}

    Decisiones de arquitectura y buenas prácticas

    • Commitea el código generado. Razón: reproducibilidad y revisiones PR que muestran cambios en el contrato. Tener el cliente en el repo permite build inmediato tras git clone.
    • No edites la carpeta generada. Crea wrappers o servicios “decorator” para añadir lógica (caching, retries, mapping).
    • Base URL dinámica: inyecta Configuration con environment.apiUrl.
    • Fechas: el spec transmite fechas como strings. Aplica un HttpInterceptor que transforme ISO strings a Date para evitar parsing repetido.
    • Enums: activa stringEnums para mejores tipos TS.
    • Naming collisions: usa additionalProperties (prefijos/sufijos) para evitar choques.

    Ejemplo rápido de interceptor para fechas:

    intercept(req, next) {
  return next.handle(req).pipe(map(event => {
    if (event instanceof HttpResponse && typeof event.body === 'object') {
      traverseAndConvertDates(event.body);
    }
    return event;
  }));
}

    CI/CD: proteger el contrato

    Añade paso en CI para regenerar y comprobar diffs. Ejemplo GitHub Actions snippet:

    - run: npm ci
- run: npm run api:generate
- run: git diff --exit-code src/app/core/api || (echo "API client changed but not committed" && exit 1)

    Si hay cambios, el pipeline falla y el equipo revisa la especificación o commitea el cliente actualizado.

    Errores comunes y cómo evitarlos

    • Editar el código generado → perderás cambios en la próxima generación. Solución: wrappers.
    • No commitear el cliente → builds frágiles. Solución: commitea.
    • Tratar fechas como strings en toda la app → lógica dispersa. Solución: interceptor centralizado.
    • Ignorar versionado de API → mezclar v1 y v2 sin control. Solución: carpetas /v1 /v2 y switch configurable.

    Conclusión

    La generación de clientes OpenAPI para Angular transforma especificaciones en código útil, confiable y mantenible. No es una moda: es una práctica de ingeniería que reduce errores, acelera el desarrollo y deja claro quién es responsable del contrato. Implementa la generación con OpenAPI Generator, commitea el cliente, encapsula extensiones y protege el flujo con CI. Tu equipo y tu base de código te lo agradecerán.

    FAQ

     

    ¿Por qué generar el cliente en lugar de copiar interfaces?

    Generar garantiza que el tipado refleje exactamente la especificación OpenAPI, evitando discrepancias que provocan errores en runtime y mejorando la detección de breaking changes.

     

    ¿Debo commitear el código generado?

    Sí. Commitear el cliente permite reproducibilidad, revisiones en PR y builds inmediatos tras clonar el repositorio.

     

    ¿Qué herramienta recomiendan para empresas?

    OpenAPI Generator es recomendado para empresas por ser maduro, configurable y con soporte comunitario. Otras opciones como ng-openapi-gen u Orval pueden encajar según necesidades.

     

    ¿Cómo manejo fechas provenientes del backend?

    Aplica un HttpInterceptor que recorra las respuestas y convierta ISO strings a objetos Date para evitar parsing repetido y lógica dispersa.

     

    ¿Cómo protejo el contrato en CI/CD?

    Incluye un paso que regenere el cliente y falle si hay diffs, forzando al equipo a revisar y commitear cambios en el cliente o la especificación.

     

    ¿Qué hago si necesito lógica adicional sobre los servicios generados?

    No modifiques la carpeta generada. Crea wrappers o servicios “decorator” para añadir caching, retries o mapping sin perder la capacidad de regenerar el cliente.

  • Cómo los desarrolladores pueden mejorar su programación colaborando con la IA

    Cómo los desarrolladores pueden mejorar su programación colaborando con la IA

    Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer?

    Tiempo estimado de lectura: 5 min

    • La sintaxis dejó de ser la ventaja: la IA genera boilerplate y código correcto rápidamente; tu valor se traslada a criterio técnico y arquitectura.
    • Prioriza sistemas y debugging: aprende a diseñar, orquestar y romper para arreglar sistemas reales.
    • Especialízate en áreas que la IA no automatiza bien: seguridad, observabilidad, integración y arquitectura.
    • Trabaja con la IA como asistente: pide tests primero, prototipa con LLMs y refactoriza aplicando patterns.

    Introducción

    Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer? Si esa frase te ronda la cabeza, respira: no es el fin, es el punto de inflexión. La IA escribe mejor sintaxis y genera boilerplate en segundos. Tu ventaja competitiva es ahora otra: criterio técnico, diseño de sistemas y orquestación.

    Este texto no es consuelo vacío. Es un plan operativo para dejar de competir con los autocompletados y empezar a liderar lo que la IA genera.

    Resumen rápido (lectores con prisa)

    Qué es: Cambio donde la generación de código vía IA convierte la sintaxis en commodity.

    Cuándo usarlo: Cuando la IA acelera prototipos y necesitas control, calidad y diseño de sistemas.

    Por qué importa: Porque el valor real pasa a la arquitectura, orquestación, seguridad y observabilidad.

    Cómo actúo: Aprende patterns, rompe y arregla sistemas, pide tests primero y especialízate en áreas no automatizadas.

    Acabo de aprender a programar, y ahora la IA programa mejor que yo, ¿Qué puedo hacer? — el cambio real

    La realidad es brutal pero simple: escribir código correcto dejó de ser escaso. Herramientas como GitHub Copilot, ChatGPT o Claude resuelven la mayor parte de las tareas de sintaxis y plantillas. Eso convierte la habilidad de teclear en una commodity.

    Pero el software no es solo líneas ejecutables. Es:

    • Decidir arquitectura.
    • Diseñar flujos de datos.
    • Evitar que una “mejora rápida” rompa TODO.
    • Traducir problemas de negocio en soluciones técnicas fiables.

    Si la IA es la máquina de escribir, tú debes convertirte en el editor, el arquitecto y el controlador de calidad.

    Qué dejar de hacer y qué empezar a practicar hoy

    1) Deja de competir en la cantera.
    No gastes tiempo memorizando APIs que la IA ya conoce. Apréndelas a nivel conceptual: ¿qué hace y por qué elegirla?

    2) Empieza a leer arquitectura, no snippets.
    Aprende patterns (Clean Architecture, Hexagonal, CQRS) y por qué existen. La IA puede generar un endpoint; no decidirá cómo encaja en tus dominios y límites contextuales.

    3) Haz del debugging tu ventaja competitiva.
    Genera código con IA. Arranca el proyecto, rompe cosas a propósito (race conditions, concurrencia, límites de memoria) y arregla esos fallos. La habilidad para diagnosticar sistemas dinámicos mantiene tu valor.

    Cuatro áreas donde tu criterio es irremplazable

    Arquitectura de software

    Elección de bases de datos, particionado, estrategia de caché.

    Integración y orquestación

    Workflows, colas, compensaciones y retry logic (aprende n8n).

    Seguridad y compliance

    Identificar vulnerabilidades reales (OWASP Top 10).

    Observabilidad y SLOs

    Diseñar alertas accionables, trazabilidad y dashboards (Prometheus/Grafana).

    Estas no son “habilidades blandas”; son el núcleo técnico que la IA no automatiza bien.

    Roadmap práctico (90 días)

    Mes 0: herramientas y mentalidad

    • Instala Copilot/Cursor en tu IDE. Úsalos como asistentes, no como reemplazo.
    • Aprende a escribir prompts técnicos: especifica inputs, outputs, constraints y tests.

    Mes 1: fundamentos sólidos

    • Profundiza en HTTP internals, asincronía, y modelos de concurrencia.
    • Haz 3 ejercicios de debugging donde rompas y arregles intencionadamente.

    Mes 2: sistemas y orquestación

    Construye una app que integre Next.js + Supabase + un workflow en n8n.

    Añade tests end‑to‑end (Cypress) y unitarios (Jest). Pide a la IA que genere tests y tú revísalos.

    Mes 3: especializa y publica

    • Elige un nicho: performance (Web Vitals: Web Vitals), seguridad, automatización.
    • Contribuye a un repo open source y haz PRs con reviews humanos.

    Cómo trabajar con la IA, no contra ella

    • Pide tests primero: solicita que la IA genere tests unitarios y funcionales; tú validas casos límite.
    • Usa la IA para prototipar, no para la versión final: genera el primer draft y refactorízalo aplicando patterns.
    • Versiona prompts y resultados: guarda los prompts que funcionan en tu repo y documenta por qué un resultado es correcto o no.
    • Automatiza orquestación: conecta agentes/LLMs a pipelines con n8n o Genkit para casos repetibles.

    Señales de que es hora de migrar a código “puro”

    La IA acelera prototipos, pero llega un momento en que necesitas control total:

    • Tráfico real que exige optimización de costes/latencia.
    • Requisitos regulatorios o de seguridad que demandan auditorías exhaustivas.
    • Lógica de negocio compleja que requiere pruebas de rendimiento y reproducibilidad.

    Si alcanzas cualquiera de estos puntos, prepara una migración: exporta modelos de datos, tests y workflows. Tener artefactos bien documentados hace la transición viable.

    Cierre — qué hacer ahora mismo

    No te rindas porque la IA escribe mejor funciones. Aprende a:

    • Pedir código con intención.
    • Romper el código y arreglarlo.
    • Diseñar sistemas y orquestar procesos.

    Empieza hoy: genera un proyecto con IA, rómpelo deliberadamente y arregla lo que falle. Ese bucle —generación, rotura, reparación— es la nueva escuela del desarrollador que quiere ser indispensable.

    Si trabajas con automatización, agentes o workflows (por ejemplo con n8n o Genkit), puede ser útil explorar recursos y experimentos prácticos que complementen este plan. Revisa Dominicode Labs para ejemplos de integración y orquestación aplicados a pipelines reales. Considera documentar prompts y pipelines allí como parte de tu repositorio de conocimiento.

    FAQ

    Respuesta: No, no dejes de aprender APIs a nivel conceptual. Evita memorizarlas; en su lugar entiende qué hacen, sus trade-offs y cuándo elegir una sobre otra.
    Respuesta: Prioriza según impacto: sistemas con alto tráfico, requisitos regulatorios o donde la seguridad/fiabilidad son críticas. También considera lo que te resulta más interesante y donde puedas aportar juicio técnico.
    Respuesta: Romper el código significa inducir fallos deliberados (ej.: condiciones de carrera, límites de memoria, fallos de red) para practicar diagnóstico y mitigación. Es una forma práctica de consolidar habilidades de debugging.
    Respuesta: Pide a la IA que genere tests antes de código de producción: unitarios y funcionales con casos límite. Tú debes revisar, completar casos faltantes y validar supuestos arquitectónicos.
    Respuesta: Migra cuando haya tráfico real que exija optimización, requisitos regulatorios o lógica de negocio compleja que necesite reproducibilidad y pruebas de rendimiento.
    Respuesta: No necesariamente. La especialización te hace más valioso en áreas críticas; además puedes combinar especialización con contribuciones generales (por ejemplo, PRs en proyectos open source).
  • Cómo crear tu primer agente con Google ADK usando Firebase Genkit

    Cómo crear tu primer agente con Google ADK usando Firebase Genkit

    Como crear tu primer agente con Google ADK ?

    Como crear tu primer agente con Google ADK ? La respuesta práctica hoy es usar Firebase Genkit: el framework code‑first de Google para construir, testear y desplegar agentes de IA en producción. Aquí tienes una guía técnica, paso a paso, pensada para desarrolladores y tech leads que quieren pasar de experimentos a agentes confiables y auditables.

    Resumen rápido (lectores con prisa)

    Firebase Genkit es un Agent Development Kit (ADK) que estructura agentes como Flows tipados, soporta tool calling y trazabilidad. Úsalo cuando necesites agentes mantenibles, testeables y auditables con deploy serverless. Funciona conectando Flows tipados con herramientas externas y desplegando como funciones HTTP.

    Qué es: un framework code‑first para agentes de IA. Por qué: trazabilidad, tests y despliegue sencillo. Cómo: define Flows (Zod), añade Tools y despliega a Firebase/Cloud Run.

    Ideas clave

    • Flows tipados: entradas y salidas validadas con Zod para reducir errores y hallucinations.
    • Tool calling: interfaz controlada a APIs/DBs que mejora seguridad y auditabilidad.
    • Trazabilidad: traces con tokens, latencias y llamadas a tools para debugging y auditoría.
    • Deploy serverless: exporta Flows como funciones HTTP y despliega con Firebase/Cloud Run.

    Tabla de contenidos

    Qué es Google ADK (Genkit) y por qué usarlo

    Firebase Genkit actúa como un “Agent Development Kit” real: estructura agentes como Flows tipados, soporta tool calling, ofrece trazabilidad (traces) y facilita deploy serverless en Firebase/Cloud Run. No es un playground: es ingeniería.

    Beneficios clave

    • Flows tipados (Zod) para entradas/salidas.
    • Tools como interfaces a APIs o DBs.
    • Trace UI para tokens, latencias y llamadas a herramientas.
    • Deploy automático a Firebase Functions/Cloud Run.

    Requisitos rápidos

    • Node.js 20+
    • Firebase CLI: npm i -g firebase-tools y firebase login
    • Proyecto Google Cloud con facturación habilitada para Vertex AI (si usas Gemini)
    • Opcional: Docker para ejecutar dev UI local

    Referencias: Vertex AI, Genkit repo.

    Paso 1 — Inicializa el scaffold (2–5 minutos)

    Crea el proyecto y usa el inicializador de genkit:

    mkdir mi-agente-genkit
cd mi-agente-genkit
npx genkit init

    El asistente te pedirá TypeScript y proveedor de modelo (Vertex AI / Gemini). Genera estructura con src/ y genkit.config.ts. Guarda las claves de API en variables de entorno, nunca en el repo.

    Paso 2 — Define el Flow: contrato y handler

    En Genkit un agente es un Flow: entrada validada, salida validada, handler con lógica y llamadas a herramientas. Usa Zod para evitar parsing frágil.

    Ejemplo mínimo

    import { genkit } from '@genkit-ai/core';
import { z } from 'zod';
import { gemini15Flash } from '@genkit-ai/googleai';

const sdk = genkit({ /* config */ });

const In = z.object({ code: z.string(), language: z.enum(['typescript','python','go']) });
const Out = z.object({ suggestion: z.string(), risk: z.enum(['LOW','MEDIUM','HIGH']) });

export const codeRefactorAgent = sdk.defineFlow(
  { name: 'codeRefactor', inputSchema: In, outputSchema: Out },
  async (input) => {
    const prompt = `Actúa como Staff Engineer... analiza este código...`;
    const resp = await sdk.generate({
      model: gemini15Flash,
      prompt,
      output: { format: 'json', schema: Out }
    });
    return resp.output(); // validado por schema
  }
);

    Puntos técnicos

    Usa output: { format: 'json', schema } para minimizar hallucinations estructurales; valida todo en entrada; añade timeouts/try‑catch.

    Paso 3 — Añade Tools (llamadas externas controladas)

    Tools son funciones que el LLM puede invocar para consultar docs, bases de datos o sistemas internos.

    Ejemplo de tool para buscar en npm registry

    const npmSearch = sdk.defineTool({
  name: 'npmSearch',
  inputSchema: z.object({ q: z.string() }),
  outputSchema: z.object({ name: z.string(), version: z.string(), desc: z.string() }),
  call: async ({ q }) => {
    const r = await fetch(`https://registry.npmjs.org/-/v1/search?text=${q}`);
    const json = await r.json();
    return json.objects[0].package;
  }
});

    El modelo decide cuándo invocar la tool; Genkit ejecuta la función y retorna el resultado al LLM. Esto mantiene seguridad y auditabilidad.

    Paso 4 — Dev UI y pruebas automáticas

    Dev UI

    Levanta la UI local: npx genkit start. En localhost:4000:

    • Ejecuta flows con JSON.
    • Inspecciona traces: prompt final, tool calls, tokens y latencia.
    • Guarda artifacts (diffs, screenshots) para auditoría.

    Pruebas automáticas

    Integra tests unitarios: mockea respuestas de tools y valida que el Flow cumple output schema. Automatiza en CI.

    Paso 5 — Deploy y orquestación

    Exporta el Flow como función HTTP y despliega

    1. firebase init functions
    2. Importa y exporta el Flow en functions/src/index.ts.
    3. firebase deploy --only functions

    Orquestación empresarial

    Para orquestación empresarial conecta el endpoint a n8n o un workflow manager: n8n → HTTP Request → parse → branch por riesgo.

    Limitaciones y criterios para migrar

    Usa Genkit cuando:

    • Necesitas trazabilidad, tests y tool calling.
    • Quieres despliegue serverless rápido.

    Migra a código tradicional si

    • La lógica es intensiva en CPU/GPU (procesamiento batch).
    • Tienes requisitos de latencia estrictos o compliance que impiden servicios cloud gestionados.
    • Coste por token/despliegue supera reescribir servicio en microservicios.

    Métrica práctica: si tu agente supera 5–10k invocaciones/mes o la fricción en coste/latencia aumenta, planifica migración.

    Buenas prácticas operativas

    • Principio de menor privilegio para tools y claves.
    • Versiona prompts como código y mantén changelogs.
    • Define SLAs y monitorea latencia, tasa de errores y ratio de respuestas estructuradas válidas.
    • Implementa fallback humano para casos de riesgo alto.

    Conclusión

    Saber cómo crear tu primer agente con Google ADK (Genkit) significa pensar en agentes como software: flujos tipados, herramientas controladas, pruebas y trazabilidad. Genkit transforma experimentos en sistemas desplegables y auditables; úsalo para prototipos robustos y como base técnica antes de escalar. Recursos y docs: Genkit, Vertex AI, repo.

    Dominicode Labs

    Si trabajas en automatización, agentes o workflows y buscas recursos prácticos y experimentos aplicados, revisa Dominicode Labs. Es una continuación lógica para prototipos técnicos y pruebas de integración.

    FAQ

    ¿Qué es Firebase Genkit y cómo se diferencia de un playground?

    Firebase Genkit es un framework code‑first para construir agentes de IA como Flows tipados, con soporte para tool calling y trazabilidad. A diferencia de un playground, está diseñado para ingeniería: testing, deploy serverless y auditoría, no solo experimentación interactiva.

    ¿Cuándo debo usar Genkit en lugar de microservicios tradicionales?

    Usa Genkit cuando necesitas trazabilidad, tests y tool calling integrados rápidamente y cuando la lógica del agente beneficia de validación tipada. Considera migrar a microservicios si la carga crece a niveles donde coste/latencia o uso intensivo de GPU/CPU hacen más eficiente una implementación dedicada.

    ¿Qué requisitos de infraestructura necesito?

    Node.js 20+, Firebase CLI (instala con npm i -g firebase-tools), y un proyecto Google Cloud con facturación habilitada para Vertex AI si usas Gemini. Docker es opcional para ejecutar la Dev UI local.

    ¿Cómo aseguro las claves y tools?

    Aplica principio de menor privilegio para las claves y cuentas de servicio. Guarda credenciales en variables de entorno o secretos gestionados; nunca en el repositorio. Limita permisos de las tools a lo estrictamente necesario.

    ¿Cómo se gestionan las pruebas y CI para Flows?

    Mockea respuestas de tools en tests unitarios y valida que los outputs cumplan el schema Zod. Automatiza esos tests en CI y añade pruebas de integración que revisen traces y artefactos relevantes.

    ¿Qué métricas debo monitorear en producción?

    Monitorea latencia, tasa de errores, tokens consumidos y ratio de respuestas válidas según el schema. Define SLAs y habilita fallback humano para casos de riesgo alto.

  • Cómo implementar evals como unit tests para LLMs

    Cómo implementar evals como unit tests para LLMs

    Qué son los evals; los unit test de los LLMs

    Tiempo estimado de lectura: 4 min

    • Los evals son unit tests para sistemas basados en LLMs: pipelines reproducibles que miden si un modelo/prompt/pipeline sigue entregando lo que el negocio necesita.
    • Tipos de evaluadores: determinista (regex/JSON Schema), semántico (embeddings + similitud) y LLM-as-a-Judge.
    • Práctica: crea un dataset representativo, define la métrica principal, implementa runner y scorer, e integra en CI/CD.

    Introducción

    Que son los evals; los unit test de los llms. Lo repito porque es la pregunta que nadie hace en serio hasta que algo falla en producción y empiezan a llover tickets.

    Resumen rápido (lectores con prisa)

    Eval: pipeline reproducible con dataset (golden set), runner, scorer y reporte que actúa como CI para la parte probabilística del sistema. Busca señales (factualidad, coherencia, formato), no igualdad exacta. Usa validación determinista, similitud de embeddings o un LLM-judge según el caso.

    ¿Qué son los evals; los unit test de los llms?

    Un eval es un pipeline reproducible: un dataset de entradas y salidas (golden set), un runner que envia prompts al modelo, un scorer que compara la respuesta con criterios, y un reporte que te dice si rompiste algo. Piénsalo como CI para la parte probabilística del sistema.

    A diferencia de un test unitario clásico, aquí no buscas igualdad exacta: buscas señales. Precisión factual, coherencia, formato JSON válido, ausencia de alucinaciones, y que el tono encaje con la interfaz. Todo eso se mide con métricas y reglas. Y sí: algunas veces el “juez” también es otro LLM.

    Tipos prácticos de evaluadores (y cuándo usarlos)

    Descripción breve de los enfoques más prácticos para evaluar salidas de LLMs y cuándo aplicarlos.

    Determinista

    Regex, validación de esquema (JSON Schema), comprobaciones de campo. Útil cuando la salida debe ser parseable. Ejemplo: validar que el LLM devuelva {"name": "...", "email": "..."}.

    Semántico

    Embeddings + similitud coseno. Ideal para summarization y Q&A donde importa el sentido, no la palabra exacta.

    LLM-as-a-Judge

    Un LLM potente evalúa las respuestas según una rúbrica. Sirve para tono, coherencia o seguridad, pero introduce sesgo y coste.

    No mezcles métricas porque sí. Prioriza la que más impacta tu negocio: si tu app depende de JSON bien formado, la métrica principal es “JSON parseable + campos obligatorios”.

    Herramientas y referencias prácticas

    Empieza con herramientas que ya existen:

    Estos proyectos te dan fixtures, runners y ejemplos para arrancar. No reinventes la rueda: adapta un benchmark a tu caso de uso.

    Cómo montar tu primer eval (en 5 pasos reales)

    Pasos concretos para crear un eval operativo.

    1. Crea un dataset de 50–100 ejemplos representativos

    Incluye casos comunes y edge cases que te aterran.

    2. Define la métrica principal

    Ej.: exact match para IDs, coseno>0.85 para respuestas semánticas, 0-1 score para seguridad.

    3. Implementa el runner

    Script que llama al LLM con el prompt actual y guarda outputs.

    4. Añade el scorer

    Validación JSON + embeddings o LLM-judge según necesites.

    5. Integra en CI/CD

    Si la puntuación baja del umbral, el pipeline falla y se bloquea el despliegue.

    Resultado: antes de tocar el botón de deploy sabes si rompiste la experiencia.

    Ejemplo corto: validar extracción de entidades en n8n

    Tienes un workflow que extrae nombre, email y producto de emails entrantes. Tu eval debería:

    • Enviar 200 emails sintéticos + reales.
    • Comprobar que el JSON sea válido.
    • Verificar que el campo email pase regex.
    • Comparar entidades con embeddings para detectar ocasionalmente false negatives.

    Si el score cae de 0.92 a 0.82 tras un cambio de prompt, no lo llames “variación normal”. Llama a la rollback.

    Peligros reales (y cómo evitarlos)

    • Data contamination: cuidado con ejemplos de test que el modelo ya vio en entrenamiento. Usa datos frescos.
    • Varianza: ejecuta cada caso varias veces (n=3–5) y usa la media o el percentil.
    • Métricas irrelevantes: BLEU o ROUGE por costumbre no te salvan; usa métricas alineadas con el objetivo del negocio.
    • Juez sesgado: si usas un LLM como juez, documenta la rúbrica y haz validaciones humanas periódicas.

    Punto para líderes técnicos

    Los evals transforman subjetividad en trazabilidad. Permiten comparar coste vs. calidad (GPT-4o-mini vs. otro) con cifras, no con intuiciones. Integrar evals es un paso pequeño en esfuerzo y gigante en reducción de riesgos.

    Haz esto ahora: crea un mini-eval con 50 ejemplos, añade una job en tu CI que ejecute el runner y falle si el score < 0.8. Si en 2 semanas no tienes alertas útiles, sube el umbral.

    No es sexy. Es necesario. Y cuando el sistema falle a las 3 a.m., agradecerás haberlos hecho.

    Dominicode Labs

    Si trabajas con automatización, IA aplicada, n8n o workflows, puede interesarte explorar recursos adicionales en Dominicode Labs. Es una continuación lógica para prototipar mini-evals y automatizar runners en pipelines existentes.

    FAQ

    Preguntas frecuentes — haz clic en una pregunta para ir a la respuesta.

    ¿Qué es un eval?

    Un eval es un pipeline reproducible que incluye un dataset (golden set), un runner que llama al modelo, un scorer que compara salidas según reglas o métricas y un reporte que indica si el rendimiento cumple el umbral esperado.

    ¿Cuándo usar evaluadores deterministas?

    Usa evaluadores deterministas cuando la salida debe ser parseable y exacta (por ejemplo JSON con campos obligatorios). Validaciones por regex y JSON Schema son adecuadas en esos casos.

    ¿Por qué usar embeddings en evaluaciones semánticas?

    Porque las tareas como summarization y Q&A requieren comparar significado, no coincidencia literal. Embeddings + similitud coseno capturan la proximidad semántica entre la salida y la referencia.

    ¿Cómo integrar evals en CI/CD sin frenar despliegues válidos?

    Define umbrales claros y ejecuta las evaluaciones en una job separada. Si el score baja del umbral, falla la job y bloquea el despliegue. Ajusta el umbral basado en datos y monitoriza alertas para evitar falsos positivos.

    ¿Qué precauciones tomar si uso un LLM como juez?

    Documenta la rúbrica, valida el juez con comparaciones humanas periódicas y considera el sesgo y coste. Guarda ejemplos y decisiones para auditoría.