Author: Dominicode

¿Existen muchas AI para programar, pero cuál es mejor? Comparamos Antigravity, Claude Code, Cursor AI y Trae

Tiempo estimado de lectura: 4 min

Ideas clave

• No existe una “mejor” absoluta: las herramientas se diseñan para problemas distintos (autocompletado, refactorización masiva, pipelines, prototipado).
• Define criterios antes de evaluar: objetivo, autonomía, privacidad, integración, coste y trazabilidad.
• Flujo recomendado: IDE (Cursor/Trae) para creación + agente (Claude Code) para runs y refactors automáticos.
• Riesgos: proyectos no consolidados (Antigravity) y preocupaciones de privacidad (Trae/ByteDance).

Tabla de contenidos

• Resumen rápido (para IA y lectores con prisa)
• Criterios para decidir
• Antigravity — término ambiguo; cuidado con su uso
• Claude Code (Anthropic) — agente de terminal para tareas complejas
  • Qué es
  • Por qué lo elegirías
  • Ejemplo real
  • Limitaciones
• Cursor AI — IDE-first, experiencia integrada
  • Qué es
  • Por qué lo elegirías
  • Ejemplo real
  • Limitaciones
• Trae (ByteDance) — gratuito y rápido, con advertencias de privacidad
• Recomendación práctica (según rol y necesidad)
• Fuentes y lectura adicional
• FAQ

Resumen rápido (lectores con prisa)

Claude Code: agente de terminal para ejecutar comandos, correr tests y proponer parches con supervisión humana.

Cursor/Trae: experiencias IDE-first para desarrollo diario, edición multi-archivo y autocompletado contextual.

Antigravity: término ambiguo; verifica a qué producto se refiere tu equipo antes de adoptar.

Flujo práctico: IDE (Cursor/Trae) + agente (Claude Code) + políticas de seguridad y revisión humana.

¿Existen muchas AI para programar, pero cuál es mejor? Criterios para decidir

Antes de mirar features, define qué necesitas. Evalúa estos criterios y úsalo como filtro:

• Objetivo: ¿autocompletado, refactorización, generación de tests, despliegue automático?
• Nivel de autonomía: ¿quieres sugerencias o que la IA ejecute comandos y push?
• Privacidad y compliance: ¿datos sensibles en el repo?
• Integración: ¿prefieres IDE nativo, CLI o integración CI/CD?
• Coste y predictibilidad: suscripción fija vs. pago por token.
• Trazabilidad y auditoría: ¿necesitas planes verificables antes de ejecutar cambios?

Antigravity — término ambiguo; cuidado con su uso

Qué es

Antigravity aparece en discusiones, pero no hay una plataforma consolidada y pública con ese nombre como líder de mercado. A menudo se confunde con proyectos internos o forks experimentales (ej. Augment/Windsurf).

Riesgo práctico

Tomar una herramienta no establecida implica soporte incierto y problemas de cumplimiento. Investiga exactamente a qué producto se refiere tu equipo antes de evaluarlo. No tomes decisiones basadas en rumores.

Fuentes generales sobre agentes y artefactos mencionan a Anthropic y proyectos experimentales en GitHub.

Claude Code (Anthropic) — agente de terminal para tareas complejas

Qué es

CLI/agent de Anthropic diseñado para “agentic coding”: ejecutar comandos, correr tests, analizar outputs y proponer parches.

Por qué lo elegirías

• Ideal para refactorizaciones masivas, migraciones o reparación automática de bugs.
• Buena comprensión del código en contexto (modelos Sonnet/Claude).
• Flujo supervisado: propone cambios y pide aprobación antes de ejecutarlos.

Ejemplo real

Pedir a Claude Code que “ejecute la suite de tests, arregle las fallas y cree un PR” — el agente puede iterar localmente hasta que pase, generando diffs y mensajes de commit.

Limitaciones

• Pago por uso; análisis de repos grandes consume tokens.
• Curva de adopción para equipos que no usan terminal de forma intensiva.
• Requiere políticas de seguridad estrictas (bloqueo de lectura de secrets).

Cursor AI — IDE-first, experiencia integrada

Qué es

Un fork/IDE con IA integrada que actúa como el editor del día a día. Sitio: Cursor.

Por qué lo elegirías

• UX nativo: Composer (ediciones multi-archivo desde una instrucción), autocompletado de bloques y aprendizaje del estilo del equipo.
• Flujo inmediato: ideal para desarrollar features, escribir componentes y refactorizar partes sin salir del editor.
• Menor fricción para onboarding del equipo (parecido a VS Code).

Ejemplo real

Pedir “refactoriza este componente React a hooks y actualiza tests” y ver los cambios aplicados inline con diffs visuales.

Limitaciones

• Suele ser de pago (modelo de suscripción).
• Menos orientado a autonomía total (no ejecuta pipelines por defecto).
• Dependencia de un fork/entorno propietario puede ser preocupación en empresas grandes.

Trae (ByteDance) — gratuito y rápido, con advertencias de privacidad

Qué es

IDE/entorno que compite con Cursor, ofreciendo muchas funciones gratuitamente. Empresa matriz: ByteDance.

Por qué lo elegirías

• Baja barrera de entrada: perfecto para prototipos, estudiantes y proyectos personales.
• Muy ágil en indexación y velocidades de respuesta.
• Builder/Composer similar a Cursor para ediciones multi-archivo.

Limitaciones críticas

• Cuestiones de privacidad y compliance en entornos corporativos por la relación con ByteDance.
• Menos maduro en auditoría y workflows empresariales comparado con soluciones orientadas a empresa.

Recomendación práctica (según rol y necesidad)

• IDE pulido para trabajo diario y equipo: empieza por Cursor. Mejor experiencia “out of the box” para escribir y refactorizar.
• Automatizar refactors complejos y PRs: añade Claude Code a tu caja de herramientas. Úsalo bajo control (branches, contenedores).
• Presupuesto cero o prototipos: Trae dará mucho valor rápido, pero no lo uses con datos sensibles sin validar compliance.
• Antigravity: no lo adoptes hasta verificar existencia, roadmap y soporte.

Combina: IDE (Cursor/Trae) para creación y revisión, más un agente (Claude Code) para runs de fondo, refactorizaciones y PRs automáticos. Integra todo con políticas de seguridad, revisión humana obligatoria y límites de gasto.

Fuentes y lectura adicional

• Anthropic
• Cursor
• ByteDance
• n8n (para integrar agentes con workflows)

No hay un vencedor único; hay decisiones conscientes. Escoge según riesgo, coste y control.

Para más experimentos con agentes y pipelines de productividad técnica, consulta también Dominicode Labs. Es un recurso compatible con flujos de automatización y pruebas de concepto, útil para equipos que diseñan integraciones entre IDEs, agentes y CI/CD.

FAQ

• ¿Cuál es la diferencia principal entre Cursor y Trae?
• ¿Claude Code puede ejecutar cambios automáticamente?
• ¿Es seguro usar Trae en proyectos corporativos?
• ¿Qué riesgos tiene adoptar herramientas no consolidadas como “Antigravity”?
• ¿Cómo integrar un agente con CI/CD?
• ¿Qué criterios debo priorizar al evaluar una AI para programar?

Angular en plataformas en la nube (AWS, Azure, Google Cloud)

Tiempo estimado de lectura: 7 min

• Decisiones arquitecturales claras.
• Opciones de entrega: SPA o SSR.
• Flujos de trabajo en AWS, Azure y Google Cloud.
• Comparativa de costes y simplicidad.
• CI/CD y observabilidad.

Tabla de contenidos

• Decisiones iniciales
• AWS: S3 + CloudFront (SPA) y App Runner / ECS (SSR)
• Azure: Static Web Apps (rápido) y Container Apps / App Service (SSR)
• Google Cloud: Firebase Hosting (rápido) y Cloud Run (contenerizado)
• Comparativa práctica
• CI/CD y observabilidad
• Dominicode Labs: automatización y resiliencia operativa
• Recomendación final
• FAQ

Decisiones iniciales

Primero define el modo de entrega:

• SPA clásico (Client-Side Rendering): ng build → dist/ estático. Ideal si el SEO no es crítico.
• SSR / Hydration (Angular Universal): necesitas Node.js para prerenderizar; útil para SEO y tiempo hasta primer render.

Documentación oficial: https://angular.io/guide/universal

AWS: S3 + CloudFront (SPA) y App Runner / ECS (SSR)

Para SPA, la combinación estándar es S3 + CloudFront. Flujo mínimo:

1. ng build --configuration production
2. Subir dist/ a S3 (configurar MIME types)
3. Servir con CloudFront y manejar fallback para rutas SPA

S3 static hosting: CloudFront default root / error handling

Importante: configurar CloudFront para servir index.html ante 403/404. En CI, ejecuta invalidación:

aws cloudfront create-invalidation --distribution-id <id> --paths "/*"

Para SSR, conteneriza y despliega en App Runner o ECS Fargate. Ventaja: control de runtime y VPC. Ejemplo Dockerfile multi-stage (build + nginx runtime para SPA o Node runtime para SSR):

# Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build -- --configuration production

# Runtime (SPA)
FROM nginx:alpine
COPY --from=builder /app/dist/my-app /usr/share/nginx/html

Azure: Static Web Apps (rápido) y Container Apps / App Service (SSR)

Azure Static Web Apps integra CI/CD con GitHub Actions y ofrece previews por pull request, rewrites automáticos y funciones serverless para APIs: https://learn.microsoft.com/azure/static-web-apps/

Configuración típica en workflow detecta Angular y ejecuta ng build. Para SSR o control total, usa Azure Container Apps o App Service con Docker y slots de despliegue. Azure Front Door añade WAF y optimización global.

Google Cloud: Firebase Hosting (rápido) y Cloud Run (contenerizado)

Firebase Hosting es la ruta más rápida para SPAs: CDN global, atomic deploys y rewrites para SPA routing (rewrites: [{source: "**", destination: "/index.html"}]). Docs: https://cloud.google.com/firebase/hosting

Para SSR o requisitos de red, empaqueta en contenedor y despliega en Cloud Run (serverless, escala a cero): https://cloud.google.com/run

Cloud Run + API Gateway funciona muy bien para aplicaciones que combinan SSR y APIs privadas.

Comparativa práctica

• Coste y simplicidad (SPA): Firebase Hosting ≈ Azure Static Web Apps > S3+CloudFront (más configuración).
• Control enterprise y VPC: AWS (ECS/Fargate) o Azure App Service.
• SSR sin gestión infra: Cloud Run es práctico; Amplify/Functions y Azure Functions son alternativas.

Calculators y docs oficiales:

• AWS CloudFront
• Azure Static Web Apps
• Firebase pricing

CI/CD y observabilidad

• Pipeline mínimo: lint → test → build → deploy → smoke tests. Usa npm ci en CI para reproducibilidad.
• Para monorepos: usa Nx y nx affected:build para reducir tiempo de builds: https://nx.dev
• Monitoreo: CloudWatch (AWS), Application Insights (Azure), Cloud Monitoring (GCP).
• Rollback: despliegues atómicos (Firebase) o blue/green + slots (Azure) para minimizar downtime.

Ejemplo rápido de pasos en GitHub Actions:

1. checkout
2. setup-node
3. npm ci
4. npm run lint
5. npm run test:ci
6. npm run build — –configuration production
7. deploy (CLI o action específica del proveedor)

Dominicode Labs: automatización y resiliencia operativa

Desplegar es solo la mitad; operar a escala es lo que cuesta tiempo. En Dominicode Labs construimos plantillas n8n y agentes que:

• Integran pipelines CI/CD con notificaciones contextuales (Slack, Jira).
• Ejecutan smoke tests post-deploy y disparan rollback si fallan.
• Analizan logs con agentes para acelerar triage.

Si tu objetivo es mantener despliegues multi-cloud y automatizar las tareas operativas alrededor del release, estas integraciones reducen fricción y tiempo de respuesta.

Recomendación final

Si necesitas lanzar rápido y a bajo coste: Firebase Hosting o Azure Static Web Apps. Si control, VPC y compliance son críticos: AWS con contenedores. Para SSR sin infra compleja: Cloud Run. Sea cual sea la nube, automatiza el pipeline y añade observabilidad desde el primer deploy. La nube gana cuando la conviertes en flujo repetible y medible.

FAQ

• ¿Qué es Angular Universal y cuándo debería usarlo?
• ¿Cuáles son las ventajas de usar AWS para Angular?
• ¿Cómo se compara Firebase Hosting con otras opciones?
• ¿Qué herramientas se recomiendan para monitoreo?
• ¿Cómo manejar el rollback en despliegues?

¿Qué es Angular Universal y cuándo debería usarlo?

Angular Universal es una tecnología para renderizar aplicaciones Angular en el servidor. Deberías usarlo si el SEO es crítico para tu aplicación o si necesitas mejorar el tiempo hasta el primer render.

¿Cuáles son las ventajas de usar AWS para Angular?

AWS ofrece un entorno completo con herramientas versátiles como S3, CloudFront, y ECS, lo que permite un alto grado de control sobre la arquitectura y el rendimiento de la aplicación.

¿Cómo se compara Firebase Hosting con otras opciones?

Firebase Hosting es ideal para aplicaciones SPA por su configuración sencilla y su CDN global. A menudo se considera más rápido y fácil de usar en comparación con opciones como S3 + CloudFront.

¿Qué herramientas se recomiendan para monitoreo?

Las herramientas recomendadas incluyen CloudWatch para AWS, Application Insights para Azure, y Cloud Monitoring para Google Cloud, que ayudan a tener visibilidad sobre el rendimiento de la aplicación.

¿Cómo manejar el rollback en despliegues?

Para manejar rollback, puedes usar despliegues atómicos en Firebase o implementar estrategias blue/green en Azure, que permiten revertir a la versión anterior rápidamente en caso de fallos.

Cómo configurar Claude Code para empezar a programar

Tiempo estimado de lectura: 4 min

• Instala y autentica la CLI de Claude Code y crea un contexto persistente con CLAUDE.md.
• Define permisos y bloquea secretos en .claude/settings.json para prevenir riesgos.
• Sigue un flujo seguro: proponer → revisar diffs → ejecutar tests → aceptar manualmente.
• Integra con IDE/CI usando API Keys limitadas y controlando contexto para reducir costes.
• Empieza con tareas pequeñas y usa /plan: para tareas complejas antes de aplicar cambios.

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

Qué es: Claude Code convierte a Claude en un agente de terminal capaz de leer el proyecto, editar archivos y ejecutar comandos.

Cuándo usarlo: Para automatizar tareas de desarrollo, refactors controlados y ejecución de tests con supervisión humana.

Por qué importa: Reduce trabajo repetitivo y acelera feedback, pero requiere límites de seguridad y control de contexto.

Cómo funciona: Instalación de una CLI, un archivo de contexto persistente (CLAUDE.md) y configuraciones de permisos que controlan qué puede ejecutar el agente.

¿Cómo configurar Claude Code para empezar a programar? — pasos esenciales

Si ese es tu objetivo, esta guía te lleva desde la instalación hasta un flujo de trabajo seguro y reproducible. No es teoría: son pasos concretos, comandos y reglas de criterio para usar Claude Code como un compañero de desarrollo real, no como un generador de snippets.

Requisitos mínimos

• macOS, Linux o Windows (WSL2 recomendado).
• Node.js 18+ y Git.
• Cuenta en Anthropic / acceso a la consola: https://console.anthropic.com
• Proyecto bajo control de versiones (Git).

Instalación (CLI global)

npm install -g @anthropic-ai/claude-code
# o, si tienes el instalador oficial:
curl -fsSL https://claude.ai/install.sh | sh

Verifica

claude --version

Autenticación

Ejecuta claude en la raíz del proyecto. Sigue el flujo interactivo que abre el navegador para autorizar tu cuenta o pega una API Key generada en la Anthropic Console.

Preferible: usa API Keys para entornos CI/servidores y suscripciones para uso local.

Inicialización del proyecto y contexto persistente

Dentro del directorio del repo ejecuta:

cd /ruta/tu-proyecto
claude
> /init

/init genera un archivo CLAUDE.md en la raíz. Este archivo es el núcleo del contexto persistente: decisiones de arquitectura, convenciones de estilo, librerías permitidas, comandos de test y patrones de seguridad. Edita CLAUDE.md con ejemplos reales y reglas claras; Claude lo leerá en cada sesión.

Ejemplo mínimo de CLAUDE.md

# CLAUDE.md
Project: payments-service
Language: TypeScript (Node 20)
Tests: npm test
Style: eslint + prettier
Auth: JWT + refresh tokens
Do not modify: /secrets, .env

Ese simple contexto reduce errores y mejora las propuestas del agente.

Permisos, seguridad y settings

Claude Code pide permisos antes de ejecutar comandos peligrosos. Define explícitamente lo que puede y no puede hacer en .claude/settings.json (local) o ~/.claude/settings.json (global).

Ejemplo:

{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm test)"
    ],
    "deny": [
      "Bash(git push*)",
      "Read(./.env)",
      "Write(./.env)"
    ]
  }
}

Regla de oro: deniega lectura/escritura de .env, claves y carpetas secrets. Mejor mover secretos a secret managers y no commitearlos.

Flujo de trabajo seguro: proponer, revisar, aplicar

1. Pide un análisis: “Resume cómo funciona auth en /src”.
2. Pide un cambio acotado: “Refactoriza la función X y muestra diff”.
3. Revisa el diff, ejecuta tests: npm test.
4. Acepta cambios y commitea manualmente; evita git push automático sin revisión.

Claude muestra diffs antes de aplicar. No apruebes cambios a ciegas.

Integración con IDE y CI/CD

• VS Code: instala la extensión oficial o usa la paleta de comandos para conectar la sesión CLI con el editor. Verás diffs lado a lado.
• CI: trata a las imágenes o builds como artefactos. En CI, utiliza API Keys con permisos limitados y un entorno de solo lectura si el agente sólo debe ejecutar tests.
• Registry: versiona imágenes usadas por los jobs de CI (docker build → push → deploy) para que el artefacto que probaste sea exactamente el que despliegas.

Costes y control de contexto

Claude tiene una ventana de contexto grande; leer repositorios grandes consume tokens. Buenas prácticas:

• Limpia contexto entre tareas con /clear.
• Limita archivos que Claude debe leer (usa .claude/paths.json si disponible).
• Configura límites de gasto (Hard Limit) en https://console.anthropic.com para evitar facturas sorpresa.

Modo Planning y tareas complejas

Antes de tocar código crítico, usa /plan: para que Claude proponga un plan (arquitectura, steps, tests). Revisa el plan como Tech Lead y autoriza solo cuando tenga sentido arquitectónico. Ese modo evita parches improvisados y cambios que rompen integraciones.

Buenas prácticas finales (resumen accionable)

• Mantén CLAUDE.md actualizado con decisiones de equipo.
• Revisa siempre diffs y tests antes de merge.
• Bloquea acceso a secretos y a git push desde el agente.
• Limita contexto y establece límites de gasto.
• Empieza con tareas pequeñas (tests, refactors) y sube la complejidad progresivamente.

Configurar Claude Code correctamente requiere algo de trabajo inicial, pero convierte la IA en un co-desarrollador útil y controlado. Empieza instalando la CLI, creando CLAUDE.md y definiendo permisos: esos tres pasos cambian por completo la calidad de las sugerencias del agente y te dan control sobre el riesgo.

Dominicode Labs

Si quieres ejemplos prácticos y plantillas de configuración para agentes y pipelines de IA, revisa los recursos de Dominicode Labs. Son útiles para adaptar patrones de seguridad y CI a tus repositorios antes de dar acceso a cualquier agente.

FAQ

Cómo crear un agente con Claude Agent SDK (TypeScript) que haga documentación de un proyecto

Tiempo estimado de lectura: 5 min

• Automatiza generación de documentación leyendo selectivamente archivos y generando README.generated.md.
• Arquitectura en tres capas: Modelo (Claude), herramientas (list_files, read_file, write_documentation) y orquestador (bucle de ejecución).
• Seguridad y límites: truncado de archivos grandes, bloqueo de .env y control de iteraciones.
• Integración en CI/CD y especial soporte para proyectos n8n y monorepos.

¿Quieres automatizar la documentación técnica sin copiar y pegar durante horas? Este artículo responde: instalación, diseño de herramientas, bucle de ejecución y recomendaciones de producción para crear un agente con Claude Agent SDK en TypeScript que genere documentación de un proyecto.

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

Un agente estructurado consta de tres capas: modelo (Claude vía API o SDK), herramientas (funciones TypeScript expuestas) y un orquestador que ejecuta un bucle de reasoning. Usa herramientas para listar/leer/escribir archivos, limita lecturas grandes y evita exponer secretos. Genera README.generated.md con resumen, estructura, componentes y ejemplos.

Arquitectura y decisión de diseño

Un agente útil no es solo un prompt. Necesitas tres capas:

• Modelo: Claude (3.5/3.7 Sonnet). Usa la API de Anthropic o su SDK: Anthropic Console.
• Herramientas (tools): funciones TypeScript que el agente puede invocar (listar, leer, escribir).
• Orquestador (bucle): lógica que procesa las peticiones del modelo y ejecuta las herramientas.

Ventaja: el agente razona sobre el código, pide archivos que necesita y no sobrecarga el contexto con todo el repo.

Requisitos y setup rápido

• Node.js >=18, TypeScript.
• Cuenta Anthropic y API key en .env (ANTHROPIC_API_KEY).
• Repo bajo Git.
• Dependencias e inicialización:

npm init -y
npm install @anthropic-ai/sdk dotenv
npm install -D typescript @types/node ts-node
npx tsc --init

Lecturas útiles: Anthropic SDK y la documentación de n8n: n8n docs.

Herramientas: qué exponer al agente

Define herramientas mínimas seguras:

• list_files(path): devuelve lista de nombres (ignora node_modules, .git).
• read_file(path): devuelve contenido (limitado por tamaño).
• write_documentation({filePath, content}): escribe Markdown.

Ejemplo simplificado en src/tools.ts:

import fs from 'fs/promises';
import path from 'path';

export const tools = [ /* definición JSON para el SDK */ ];

export async function executeTool(name: string, args: any) {
  const base = process.cwd();
  if (name === 'list_files') return JSON.stringify(await fs.readdir(path.join(base, args.path)));
  if (name === 'read_file') return await fs.readFile(path.join(base, args.path), 'utf-8');
  if (name === 'write_documentation') { await fs.writeFile(path.join(base, args.filePath), args.content); return 'ok'; }
  throw new Error('tool unknown');
}

Reglas: limita lectura de archivos grandes y bloquea .env o carpetas secrets.

System prompt y flujo de trabajo

Define un system prompt que actúe como directiva: papel (Technical Writer Senior), pasos (listar, leer, sintetizar, escribir), y reglas (no inventar, referenciar código). Ejemplo breve:

"Analiza el código en ./src. Usa list_files y read_file. Genera README.generated.md con: resumen, estructura, componentes, ejemplos de uso. No inventes funcionalidades."

Flujo básico en src/index.ts:

• 1. Inicia sesión con la API.
• 2. Envía prompt inicial.
• 3. Espera respuesta: si el modelo solicita tool_use, ejecuta la herramienta y devuelve resultado como tool_result.
• 4. Repite hasta que el modelo entregue Markdown final o alcance iteraciones límite.

Este patrón evita enviar todo el repo en un solo prompt y controla consumo de tokens.

Ejecución: control de iteraciones y seguridad

Ejecuta con npx ts-node src/index.ts. Implementa:

• Límite de iteraciones (ej. 10 turns).
• Límite de tamaño por archivo leído (truncate >50KB).
• Permisos explícitos en .claude/settings.json o el equivalente: denegar git push automático, bloquear lectura de .env.

Para entornos productivos, ejecuta el agente dentro de un contenedor Docker: Docker y escanea imágenes con Trivy: Trivy.

Integración CI/CD y n8n

En CI, ejecuta el agente en una job que solo escriba en la rama del PR o en un branch docs/auto.

Para proyectos n8n, usa el agente para parsear workflows JSON exportados y generar diagramas Mermaid; permite llamar a herramientas MCP o endpoints de parsing si necesitas lógica más rica (ver MCP y herramientas personalizadas en el SDK de Anthropic).

Costes, contexto y buenas prácticas

• Tokens y contexto: leer muchos archivos incrementa coste. Filtra por extensión y relevancia (usar ripgrep para búsquedas puntuales).
• Idempotencia: la escritura debe sobrescribir el fichero objetivo para evitar inconsistencias entre ejecuciones.
• Revisión humana obligatoria: el agente sugiere; el equipo revisa antes del merge.
• Monitoreo: registra costes por ejecución y errores; guarda artefactos en artifacts del CI.

Ejemplo de salida esperada (estructura del README.generated.md)

El README generado debe incluir:

• Resumen del proyecto.
• Diagrama de componentes / Mermaid.
• Listado de workflows (n8n) o endpoints.
• Requisitos y comandos Docker/compose.
• Sección “Qué revisar” con puntos detectados por el agente (tests faltantes, endpoints sin doc).

Conclusión: por qué esto importa y siguientes pasos

Crear un agente con Claude Agent SDK (TypeScript) para documentar proyectos no es magia: es ingeniería. Proporciona repetibilidad, reduce deuda técnica y acelera onboarding.

Implementa las herramientas mínimas, establece límites claros y arranca con tareas pequeñas (módulos, workflows). Siguiente paso: integrar el agente en tu pipeline de PRs y convertir la documentación automática en un artefacto revisable.

Mención: Dominicode Labs

Para equipos que quieran experimentar con flujos y agentes, una siguiente etapa lógica es explorar recursos y prototipos en Dominicode Labs. Allí puedes encontrar ejemplos prácticos y plantillas que encajan con pipelines automatizados y documentación generada.

FAQ

• ¿Qué herramientas mínimas debe exponer el agente?
• ¿Cómo evito que el agente lea secretos?
• ¿Cuál es el flujo básico de interacción con el modelo?
• ¿Cómo controlar el coste de tokens?
• ¿Dónde debo ejecutar el agente en producción?

¿Qué herramientas mínimas debe exponer el agente?

Exponer al menos las tres herramientas: list_files, read_file y write_documentation. Con ellas el agente puede descubrir estructura, recuperar contenido relevante y escribir el Markdown final.

Limita la lista de archivos y controla el tamaño de lectura para evitar costes y exponer datos innecesarios.

¿Cómo evito que el agente lea secretos?

Implementa reglas en las herramientas para bloquear rutas como .env, carpetas secrets o cualquier patrón sensible. Añade permisos explícitos en un fichero de settings (por ejemplo .claude/settings.json) y niega operaciones peligrosas como git push.

¿Cuál es el flujo básico de interacción con el modelo?

Inicia sesión con la API, envía un prompt inicial que define el rol y las reglas, espera la respuesta del modelo. Si el modelo pide usar una herramienta, ejecuta la herramienta y devuelve el resultado como tool_result. Repite hasta obtener el Markdown final o alcanzar el límite de iteraciones.

¿Cómo controlar el coste de tokens?

Filtra archivos por extensión y relevancia, evita enviar grandes blobs de código en un solo prompt y limita el número de iteraciones. Usa herramientas de búsqueda como ripgrep para identificar rápidamente archivos relevantes.

¿Dónde debo ejecutar el agente en producción?

En un contenedor Docker con escaneo de imágenes (por ejemplo con Trivy). En CI, limita permisos y haz que el agente escriba solo en ramas de PR o en una rama docs/auto.