Curso de Claude Code para tu equipo de desarrollo — Productividad

Comprender el agent loop: objetivo, razonamiento interno del modelo, solicitud de herramienta, ejecución y nuevo contexto.

Diferenciar tareas de una sola respuesta, tareas multi-step, tareas con herramientas y tareas autónomas largas.

Identificar cuándo un agente debe actuar, pedir confirmación, delegar, detenerse o devolver una recomendación.

Diseñar límites de autonomía para evitar acciones inesperadas, bucles largos, gasto excesivo o cambios no autorizados.

Entender la diferencia entre instrucciones del sistema, prompt de tarea, contexto del repositorio, herramientas y resultados.

Analizar patrones de uso: bug fixer, code reviewer, research agent, documentación, QA, soporte técnico y automatización CI/CD.

Detectar riesgos propios de agentes: prompt injection, tool misuse, edición incorrecta, fuga de datos y decisiones opacas.

Crear una matriz de autonomía: solo lectura, edición controlada, ejecución de tests, cambios con aprobación y despliegue.

Definir criterios de finalización: resultado suficiente, límite de turnos, coste máximo, error crítico o intervención humana.

Realizar ejercicio de diseño de un agente con objetivo, herramientas, límites, entradas, salidas y criterios de parada.

Crear agentes básicos en Python usando `query()` como generador asíncrono.

Configurar `ClaudeAgentOptions` con herramientas permitidas, directorio de trabajo, modelo, turnos y entorno.

Procesar mensajes del stream para extraer resultados, estados, errores y métricas.

Definir prompts de tarea claros para análisis de archivos, búsqueda de TODOs, revisión de configuración o generación de informe.

Controlar el directorio `cwd` para evitar que el agente lea o modifique ubicaciones no autorizadas.

Limitar herramientas con `allowed_tools` para construir agentes de solo lectura o edición controlada.

Capturar excepciones, timeouts externos, fallos de autenticación y errores de herramienta.

Diseñar scripts Python reutilizables para automatizaciones internas.

Separar configuración, prompts, opciones, logging y lógica de negocio.

Realizar ejercicio de agente Python que analiza un repositorio y genera informe técnico sin modificar archivos.

Crear agentes en TypeScript con `@anthropic-ai/claude-agent-sdk`.

Gestionar streams de mensajes con `for await` y procesar resultados progresivos.

Configurar opciones de ejecución, herramientas, `cwd`, entorno, permisos y límites de turnos.

Entender el binario nativo de Claude Code incluido como dependencia opcional del SDK.

Integrar agentes en scripts Node.js, CLIs internas, servicios backend o jobs programados.

Controlar errores de instalación, dependencias opcionales, rutas de ejecutable y compatibilidad de plataforma.

Crear wrappers tipados para tareas repetibles: revisar PR, documentar módulo, analizar tests o generar migración.

Estructurar proyecto TypeScript con configuración, tipos, adaptadores, prompts y tests.

Evitar mezclar lógica de agente con lógica de negocio sin capa de aislamiento.

Realizar ejercicio de CLI TypeScript para ejecutar un agente de revisión de repositorio.

Diferenciar `query()` para tareas acotadas y `ClaudeSDKClient` para conversaciones o sesiones persistentes.

Crear agentes que mantienen contexto a través de múltiples intercambios.

Reanudar sesiones usando identificadores persistentes cuando el caso lo requiere.

Diseñar conversaciones largas sin crecimiento incontrolado de contexto, coste o memoria.

Gestionar interrupciones, input streaming y nuevas instrucciones durante una sesión activa.

Separar sesiones por usuario, proyecto, tenant, repositorio o caso de uso.

Evitar contaminación de contexto entre sesiones o clientes distintos.

Crear estrategia para guardar metadatos de sesión, estado externo y resultados de negocio.

Definir cuándo cerrar, archivar, resumir o reiniciar una sesión.

Realizar ejercicio de agente conversacional que analiza un proyecto por fases y retoma el trabajo.

Usar `Read` para analizar archivos concretos con control de alcance.

Usar `Glob` para localizar patrones de archivos sin recorrer repositorios enteros innecesariamente.

Usar `Grep` para buscar código, configuración, dependencias, TODOs, secretos simulados o patrones de error.

Usar `Edit` y `Write` para modificar o crear archivos con permisos explícitos.

Usar `Bash` de forma restringida para ejecutar tests, linters, scripts y comandos Git autorizados.

Usar `Monitor` para observar procesos o comandos de larga duración cuando el caso lo justifica.

Evaluar cuándo `WebSearch` y `WebFetch` son apropiados para investigación técnica o documentación actual.

Controlar permisos de herramientas según el tipo de agente: lector, editor, tester, investigador o operador.

Registrar cada uso de herramienta para auditoría y depuración.

Realizar ejercicio de agente que detecta un fallo, edita código y ejecuta pruebas en entorno de laboratorio.

Diseñar prompts de sistema que establecen rol, límites, criterios de decisión y estilo de salida.

Diferenciar instrucciones permanentes, instrucciones por tarea, contexto de proyecto y reglas de seguridad.

Evitar prompts ambiguos que permiten al agente tomar decisiones no autorizadas.

Incorporar políticas: no tocar producción, no ejecutar comandos destructivos, no exponer secretos y pedir aprobación.

Definir formatos de salida: informe técnico, diff propuesto, checklist, JSON, Markdown, ticket o resumen ejecutivo.

Incorporar criterios de calidad: pruebas obligatorias, explicación de cambios, riesgos y rollback.

Crear prompts adaptados a roles: code reviewer, QA agent, release assistant, documentation agent y security analyst.

Versionar prompts como artefactos del proyecto y revisarlos mediante pull request.

Medir impacto de cambios de prompt sobre precisión, coste, latencia y seguridad.

Realizar ejercicio de diseño y mejora iterativa de prompt de sistema para agente de revisión de código.

Definir salidas estructuradas para integrar agentes con aplicaciones, pipelines y sistemas internos.

Diseñar esquemas JSON para resultados, hallazgos, acciones, riesgos, evidencias y decisiones.

Validar salidas del agente antes de activar acciones posteriores.

Separar texto para humanos y datos estructurados para automatización.

Gestionar errores de schema, campos ausentes, valores inesperados y respuestas parciales.

Crear normalizadores para convertir resultados del agente en tickets, informes, métricas o cambios de estado.

Evitar que una respuesta narrativa active decisiones automáticas sin validación.

Diseñar contratos de salida por caso de uso: revisión, auditoría, documentación, investigación, QA o despliegue.

Integrar validación con tests automatizados y checks de pipeline.

Realizar ejercicio de agente que devuelve hallazgos estructurados y bloquea resultados inválidos.

Comprender cuándo crear herramientas propias en lugar de usar solo herramientas integradas.

Diseñar herramientas con nombre, descripción, schema de entrada, salida clara y errores controlados.

Implementar herramientas para consultar APIs internas, leer tickets, obtener métricas o ejecutar validaciones de negocio.

Limitar herramientas por caso de uso para evitar sobreexposición de capacidades.

Crear tools idempotentes cuando puedan ejecutarse varias veces.

Separar herramientas de lectura, herramientas de escritura y herramientas de acción irreversible.

Diseñar allowlists, validación de parámetros y límites de frecuencia.

Registrar llamadas, payloads permitidos, resultados, duración y usuario asociado.

Evitar exponer credenciales directamente al agente.

Realizar ejercicio de custom tool para consultar un sistema ficticio de tickets o inventario técnico.

Comprender Model Context Protocol como mecanismo para conectar agentes con herramientas, datos y servicios externos.

Diferenciar custom tools locales, MCP servers y conectores de plataforma.

Conectar un MCP server de laboratorio para navegación, documentación, base de datos, tickets o repositorio.

Diseñar permisos por servidor MCP y por herramienta expuesta.

Controlar credenciales, egress, logs y datos devueltos por servidores MCP.

Evitar MCP servers demasiado amplios que convierten al agente en operador sin límites.

Incorporar herramientas MCP para Playwright, documentación, APIs internas o consultas controladas.

Monitorizar llamadas MCP, errores, latencia y resultados devueltos al agente.

Crear criterios para aprobar MCP servers en una organización.

Realizar ejercicio de agente que usa MCP para obtener contexto externo y producir un informe accionable.

Comprender qué son los subagentes y cómo separan tareas en contextos independientes.

Diseñar subagentes para revisión de seguridad, documentación, testing, arquitectura, investigación y análisis de logs.

Definir descripción, prompt, herramientas y permisos específicos para cada subagente.

Usar el `Agent` tool de forma controlada para permitir delegación.

Evitar subagentes genéricos que duplican trabajo, consumen tokens y devuelven resultados redundantes.

Diseñar patrones de coordinación: investigador, planificador, implementador, revisor y sintetizador.

Limitar fan-out paralelo para evitar costes excesivos, saturación o rate limits.

Rastrear qué subagente generó cada hallazgo usando metadatos y trazabilidad.

Definir cuándo un subagente puede proponer cambios y cuándo solo puede informar.

Realizar ejercicio de equipo multiagente para analizar, corregir y revisar una base de código.

Comprender los hooks como puntos de intervención en el ciclo de vida del agente.

Usar `PreToolUse` para validar, bloquear o pedir aprobación antes de una herramienta.

Usar `PostToolUse` para registrar auditoría, validar efectos o disparar checks posteriores.

Usar hooks de sesión para inicializar contexto, cargar reglas o limpiar recursos.

Implementar hooks de comando, HTTP, MCP tool, prompt o agent según el caso.

Crear hooks para bloquear comandos peligrosos, escrituras no autorizadas o accesos fuera de ruta.

Registrar cambios de archivos, comandos ejecutados, duración, resultado y usuario.

Evitar hooks que añaden demasiada latencia o fallan de forma opaca.

Probar hooks con casos permitidos, bloqueados, fallidos y ambiguos.

Realizar ejercicio de agente con hook de auditoría y bloqueo preventivo de comandos de riesgo.

Diseñar un modelo de permisos por herramienta, comando, ruta, entorno y tipo de acción.

Diferenciar reglas allow, deny, ask, modos de permiso y callbacks dinámicos.

Aplicar principio de mínimo privilegio para agentes de lectura, edición, testing o despliegue.

Crear flujos de aprobación humana para acciones sensibles.

Implementar `canUseTool` para decidir en tiempo real si una herramienta puede ejecutarse.

Bloquear comandos destructivos, acceso a secretos, escritura fuera de repositorio y operaciones de red no autorizadas.

Separar permisos de desarrollo, CI/CD, producción, usuarios internos y tenants externos.

Registrar aprobaciones, denegaciones, justificación y resultado final.

Crear pruebas de permisos para demostrar que los límites se cumplen.

Realizar ejercicio de agente con permisos read-only, permisos de edición y aprobación humana para comandos.

Identificar amenazas específicas de agentes: prompt injection, tool misuse, exfiltración y acciones no esperadas.

Analizar cómo instrucciones maliciosas en archivos, webs, tickets o documentación pueden influir en el agente.

Diseñar fronteras de seguridad: aislamiento, permisos, validación, red, credenciales y revisión humana.

Aplicar defensa en profundidad para que un fallo de modelo no implique un fallo operativo.

Limitar acceso a datos sensibles, secretos, credenciales, repositorios privados y sistemas críticos.

Evitar que el agente tenga credenciales directas cuando puede usarse un proxy o servicio intermedio.

Registrar evidencias de seguridad y auditoría sin almacenar contenido sensible innecesario.

Incorporar revisión de seguridad en prompts, tools, MCP servers, hooks y despliegue.

Crear playbooks de respuesta ante acción indebida, fuga de datos o comportamiento inesperado.

Realizar ejercicio de threat modeling de una solución agéntica corporativa.

Comprender por qué un agente capaz de leer archivos y ejecutar comandos debe ejecutarse en entorno aislado.

Diseñar sandbox por sesión, usuario, tenant, repositorio o tarea.

Evaluar aislamiento con contenedores, gVisor, Firecracker, máquinas virtuales o proveedores sandbox gestionados.

Separar directorios de trabajo, configuraciones, memoria, transcripts y artefactos por sesión.

Aplicar límites de CPU, memoria, disco, duración, número de turnos y tamaño de salida.

Controlar tráfico saliente con proxy, allowlists de dominios y logs de egress.

Diseñar filesystem de solo lectura para código base y áreas concretas de escritura.

Evitar contenedores compartidos sin separación de configuración, memoria y rutas.

Preparar procedimiento de limpieza de artefactos temporales y datos residuales.

Realizar ejercicio de arquitectura de sandbox para agente que modifica código de forma controlada.

Separar credenciales de modelo, credenciales de herramientas y credenciales de usuario final.

Usar secret managers o variables seguras gestionadas por la plataforma, no archivos dentro del workspace.

Diseñar proxy de credenciales para inyectar tokens después de validar la petición del agente.

Evitar que el agente pueda leer directamente claves API, tokens, certificados o variables sensibles.

Aplicar credenciales por entorno, tenant, herramienta, alcance y duración.

Rotar credenciales usadas por agentes y registrar uso anómalo.

Controlar secretos expuestos accidentalmente en logs, resultados de herramientas o transcripts.

Integrar detección de secretos en repositorios y salidas del agente.

Crear políticas de revocación inmediata ante comportamiento no autorizado.

Realizar ejercicio de diseño de acceso seguro a una API interna desde un agente.

Comprender qué estado vive en disco: transcripts, memoria, archivos de proyecto y artefactos de trabajo.

Diseñar persistencia de sesiones cuando el usuario necesita retomar tareas más tarde.

Usar `resume` y estrategias de almacenamiento externo para continuidad.

Separar transcript del agente, estado de aplicación, memoria del proyecto y artefactos generados.

Evitar pérdidas de estado por reinicio de contenedor, escalado o movimiento entre nodos.

Gestionar almacenamiento en S3, Redis, Postgres u otra solución corporativa mediante adaptadores.

Definir políticas de retención, borrado, cifrado y acceso a transcripts.

Evitar que memoria o configuración de un tenant se cargue en sesiones de otro.

Crear resúmenes de sesión para reducir contexto sin perder decisiones importantes.

Realizar ejercicio de agente con sesión persistente y reanudación controlada.

Comparar ejecución local, scripts internos, jobs CI/CD, servicios backend, contenedores y agentes gestionados.

Diseñar agentes efímeros para tareas puntuales como revisión de PR, análisis de bug o generación de documentación.

Diseñar agentes long-running para asistentes internos, bots, triaje continuo o flujos conversacionales.

Diseñar patrón híbrido para sesiones que se pausan y reanudan entre interacciones.

Evaluar uso de Managed Agents cuando se quiere reducir operación de infraestructura propia.

Planificar despliegues en Docker, Kubernetes, sandbox providers, cloud corporativo o infraestructura interna.

Definir balanceo, afinidad de sesión, escalado horizontal y reciclado de procesos.

Controlar límites de concurrencia y evitar fan-outs masivos de subagentes.

Crear checklist de preparación para pasar de prototipo a producción.

Realizar ejercicio de selección de arquitectura para tres casos de uso corporativos.

Configurar autenticación con Anthropic API mediante `ANTHROPIC_API_KEY`.

Revisar alternativas corporativas como Amazon Bedrock, Vertex AI o Azure AI Foundry cuando la empresa lo requiere.

Separar configuración de proveedor, modelo, región, endpoint y credenciales.

Diseñar abstracción para cambiar de proveedor sin reescribir la lógica de agente.

Entender limitaciones, diferencias de disponibilidad, latencia, costes y gobierno por proveedor.

Registrar proveedor usado, modelo, versión, región, política de datos y controles aplicados.

Evitar mezclar claves personales y credenciales corporativas.

Crear entornos separados para desarrollo, pruebas, preproducción y producción.

Diseñar pruebas de compatibilidad para herramientas, modelos, streaming y sesiones según proveedor.

Realizar ejercicio de configuración multi-entorno con proveedor seleccionable por variable segura.

Activar telemetría del Agent SDK mediante variables de entorno y exportadores OTLP.

Exportar métricas, trazas y eventos a un collector corporativo.

Observar llamadas a modelo, uso de herramientas, duración, errores, tokens y decisiones de permisos.

Etiquetar telemetría por usuario, tenant, agente, caso de uso, versión, entorno y sesión.

Crear dashboards de salud para agentes: latencia, coste, errores, herramientas usadas y sesiones activas.

Detectar puntos donde el agente se queda bloqueado, repite herramientas o consume demasiados turnos.

Filtrar datos sensibles para no exportar prompts o tool inputs sin autorización.

Integrar observabilidad con Grafana, Datadog, Honeycomb, Langfuse, OpenTelemetry Collector u otra plataforma.

Crear alertas operativas ante errores, costes anómalos, rate limits, fallos de herramientas o timeouts.

Realizar ejercicio de agente instrumentado con OpenTelemetry y dashboard de diagnóstico.

Medir uso de tokens por paso, por modelo, por sesión y por resultado final.

Interpretar costes estimados del SDK frente a facturación autorizada de la plataforma.

Establecer presupuestos por usuario, equipo, agente, entorno y caso de uso.

Limitar `maxTurns`, fan-out de subagentes, tamaño de contexto, búsqueda y uso de herramientas costosas.

Diseñar prompts y workflows que reduzcan vueltas innecesarias.

Usar caching de prompts cuando el patrón de uso lo justifica y la política lo permite.

Detectar agentes que consumen mucho sin entregar valor suficiente.

Crear informes de coste por feature, release, tenant o centro de coste.

Definir criterios de apagado, degradación o aprobación cuando se supera un umbral.

Realizar ejercicio de optimización de coste de un agente multi-step.

Diseñar pruebas funcionales para verificar que el agente cumple su objetivo.

Crear datasets de tareas representativas: bugs, PRs, documentación, tickets, logs y repositorios.

Medir precisión, completitud, seguridad, coste, latencia, robustez y tasa de intervención humana.

Probar límites: prompts maliciosos, archivos grandes, errores de herramienta, permisos denegados y respuestas incompletas.

Crear tests de regresión para prompts, tools, hooks, subagentes y configuración.

Validar que el agente no modifica archivos fuera del alcance autorizado.

Comparar comportamiento entre modelos, versiones de SDK y configuraciones de permisos.

Incorporar revisión humana en tareas de alto impacto.

Crear scoring de resultados y criterios de aceptación antes de producción.

Realizar ejercicio de suite de evaluación para agente de revisión de código.

Versionar prompts, tools, hooks, subagentes, MCP config, permisos y scripts de despliegue.

Crear pipeline para ejecutar tests de agente en cada pull request.

Validar seguridad: secretos, permisos, comandos prohibidos, cambios de herramientas y dependencias.

Publicar artefactos de agente: paquete, imagen, configuración, prompts y changelog.

Separar despliegues por entorno: desarrollo, sandbox, preproducción y producción.

Aplicar aprobaciones manuales para agentes con permisos de escritura o acceso a datos sensibles.

Ejecutar smoke tests después del despliegue con tareas controladas.

Preparar rollback de prompt, modelo, configuración, herramienta o imagen.

Documentar cambios que afectan coste, permisos, alcance o comportamiento.

Realizar ejercicio de pipeline CI/CD para publicar un agente corporativo con gates de seguridad.

Analizar latencia total: modelo, herramientas, IO, red, MCP, hooks, subagentes y aplicación host.

Reducir llamadas innecesarias a herramientas mediante mejores prompts y contexto inicial.

Diseñar herramientas rápidas, cacheables, idempotentes y con respuestas compactas.

Ajustar concurrencia, límites de sesión, tamaño de contexto y número de subagentes.

Preparar cold starts y warm pools para agentes de uso frecuente.

Medir impacto de `cwd`, tamaño de repositorio, búsquedas amplias y lectura de archivos grandes.

Optimizar streaming para mejorar experiencia de usuario en aplicaciones interactivas.

Detectar cuellos de botella con trazas OpenTelemetry y logs estructurados.

Crear benchmarks representativos para comparar versiones.

Realizar ejercicio de reducción de latencia de un agente con varias herramientas.

Construir un agente de revisión de código con criterios de calidad, seguridad y mantenibilidad.

Crear agente de documentación que explora repositorios y genera guías técnicas actualizadas.

Diseñar agente de refactorización con permisos de edición y ejecución de tests controlados.

Preparar agente de análisis de deuda técnica con salida estructurada y prioridad de acciones.

Integrar comentarios de PR, checklists y resúmenes ejecutivos para tech leads.

Evitar que el agente proponga cambios masivos sin dividirlos en pasos revisables.

Validar cambios con linters, tests unitarios y análisis estático.

Generar diffs explicados con riesgo, impacto y rollback.

Registrar evidencias para auditoría de cambios automáticos.

Realizar ejercicio de agente que revisa, documenta y propone mejoras sobre un módulo.

Diseñar agentes que leen código y proponen casos de prueba relevantes.

Generar pruebas unitarias, integración, contrato o E2E según arquitectura del proyecto.

Identificar huecos de cobertura y riesgos funcionales.

Ejecutar test suites permitidas y resumir fallos con causa probable.

Crear datos de prueba sintéticos sin usar datos sensibles.

Revisar flaky tests, errores intermitentes y dependencias de entorno.

Generar informes de regresión vinculados a cambios de código.

Integrar resultados con pipelines CI/CD y herramientas de QA.

Evitar aprobar automáticamente cambios de test sin revisión humana cuando afectan lógica crítica.

Realizar ejercicio de agente QA que crea pruebas y analiza fallos de una suite.

Crear agentes que leen logs, métricas, tickets y documentación para resumir incidencias.

Conectar herramientas de observabilidad mediante MCP o custom tools controladas.

Diseñar workflows para diagnóstico de errores, regresiones, timeouts, despliegues fallidos y cambios recientes.

Generar hipótesis con evidencias y próximos pasos.

Evitar que el agente ejecute acciones correctivas sin aprobación.

Preparar respuestas para equipos de soporte, SRE, desarrollo o cliente interno.

Integrar runbooks y documentación operativa en el contexto del agente.

Registrar decisiones, herramientas consultadas y evidencias usadas.

Crear informe post-incidencia con causa probable, impacto, mitigación y prevención.

Realizar ejercicio de agente de análisis de incidencia con logs y métricas simuladas.

Diseñar agentes que investigan documentación interna, repositorios, wikis, PDFs y páginas web autorizadas.

Separar búsqueda, lectura, síntesis, validación y generación de entregable.

Usar subagentes para explorar fuentes sin saturar el contexto principal.

Conectar fuentes mediante MCP o herramientas de búsqueda controladas.

Crear salidas reutilizables: guías, comparativas, resúmenes, FAQs, informes y planes técnicos.

Detectar información contradictoria, obsoleta o insuficiente.

Registrar fuentes, supuestos y lagunas de información.

Evitar incluir datos sensibles o confidenciales en entregables compartidos.

Evaluar calidad de la respuesta mediante criterios de exactitud, trazabilidad y utilidad.

Realizar ejercicio de research agent que genera una guía técnica basada en varias fuentes.

Diseñar equipos de agentes con roles diferenciados: investigador, arquitecto, implementador, tester, auditor y sintetizador.

Definir protocolo de colaboración entre agentes para evitar duplicidad y conflicto.

Usar subagentes paralelos con límites de coste, turnos y herramientas.

Agregar resultados mediante un agente coordinador que prioriza, deduplica y valida.

Resolver discrepancias entre agentes con criterios explícitos.

Diseñar flujos de revisión cruzada para seguridad, calidad y arquitectura.

Evitar arquitecturas multiagente innecesarias cuando un agente simple basta.

Medir coste y latencia añadidos por cada subagente.

Documentar trazabilidad de decisiones y contribución de cada agente.

Realizar ejercicio de equipo multiagente para analizar una arquitectura y proponer plan de mejora.

Definir política interna de uso de Claude Agent SDK y agentes autónomos.

Clasificar agentes por riesgo: informativo, asistido, semi-autónomo, escritura controlada y acción crítica.

Establecer owners, aprobadores, usuarios autorizados, revisiones periódicas y retirada de agentes obsoletos.

Crear catálogo corporativo de agentes, herramientas, prompts, modelos, permisos y fuentes de datos.

Incorporar controles sobre datos personales, propiedad intelectual, secretos, decisiones automatizadas y auditoría.

Definir cuándo una acción requiere humano en el circuito.

Preparar documentación para usuarios: alcance, límites, riesgos, soporte y responsabilidades.

Medir adopción, calidad, ahorro de tiempo, errores evitados y satisfacción de usuarios.

Crear proceso de mejora continua con feedback, incidentes, evaluaciones y cambios de versión.

Realizar ejercicio de modelo de gobierno para una plataforma interna de agentes.

Diseñar agentes de revisión de pull requests con evidencia, comentarios y checks automáticos.

Crear agentes de migración de código entre frameworks, versiones o estándares internos.

Construir agentes de documentación viva para repositorios y APIs.

Crear agentes de cumplimiento técnico que revisan licencias, secretos, dependencias y estándares.

Diseñar agentes de data engineering para explorar pipelines, errores y contratos de datos.

Construir asistentes internos para soporte técnico y búsqueda de conocimiento.

Crear agentes de reporting ejecutivo a partir de datos estructurados y documentos.

Diseñar agentes de mantenimiento de backlog técnico y priorización de deuda.

Evaluar patrones que no convienen: agentes con permisos excesivos, acciones irreversibles o acceso indiscriminado.

Realizar ejercicio de selección y diseño de tres casos de uso priorizados por valor, riesgo y viabilidad.

Diagnosticar errores de instalación, dependencias nativas, binario Claude Code y compatibilidad de plataforma.

Resolver problemas de autenticación, variables de entorno, proveedor API y configuración de endpoints.

Identificar fallos de permisos, herramientas bloqueadas, hooks mal configurados y aprobaciones no resueltas.

Investigar sesiones colgadas, loops largos, consumo elevado, rate limits y timeouts.

Depurar fallos de MCP servers, latencia de herramientas y respuestas inesperadas.

Revisar errores de telemetría, exportadores OTLP, collector no disponible y logs incompletos.

Analizar diferencias entre entorno local, CI/CD, contenedor y producción.

Preparar runbooks de recuperación, reinicio, limpieza de sesión y rollback.

Crear checklist de diagnóstico antes de escalar a proveedor, plataforma o seguridad.

Realizar ejercicio de resolución de incidencias provocadas en un agente desplegado.

Diseñar estrategia de adopción por fases: piloto, sandbox, casos controlados, producción limitada y escalado.

Priorizar casos de uso por valor, riesgo, complejidad, datos, integración y madurez del equipo.

Crear un centro de excelencia con estándares, plantillas, prompts, tools, evaluaciones y soporte.

Definir roles: product owner de agente, tech lead, security reviewer, platform owner y business owner.

Establecer proceso de alta de nuevos agentes y revisión periódica de agentes existentes.

Crear biblioteca de componentes reutilizables: hooks, permissions, MCP configs, prompts y evaluadores.

Medir retorno: tiempo ahorrado, calidad, errores evitados, adopción, coste y satisfacción.

Integrar agentes en procesos existentes sin crear shadow IT.

Preparar plan de comunicación y formación interna para usuarios y equipos técnicos.

Realizar ejercicio de roadmap de 90 días para adopción de Claude Agent SDK en una empresa.

Diseñar una solución agéntica avanzada basada en Claude Agent SDK para un caso de uso empresarial realista.

Seleccionar caso: revisión de código, QA, documentación, soporte, incidencias, investigación técnica o automatización CI/CD.

Definir alcance funcional, usuarios, riesgos, datos tratados, herramientas necesarias y límites de autonomía.

Crear arquitectura objetivo con aplicación host, SDK, sesiones, herramientas, MCP, observabilidad y despliegue.

Implementar agente base en Python o TypeScript usando `query()` o `ClaudeSDKClient`.

Configurar herramientas integradas con permisos mínimos: lectura, búsqueda, edición controlada y comandos autorizados.

Crear al menos una custom tool para consultar información externa o sistema simulado.

Integrar un MCP server de laboratorio o diseñar su contrato de uso empresarial.

Definir subagentes especializados para investigación, revisión, testing, seguridad o documentación.

Implementar hooks para auditoría, bloqueo de acciones peligrosas y validación posterior de herramientas.

Crear prompts de sistema versionados con límites, criterios de parada, formato de salida y política de seguridad.

Diseñar structured output para hallazgos, acciones, riesgos, evidencias y recomendaciones.

Añadir persistencia o estrategia de reanudación de sesión cuando el caso lo requiera.

Instrumentar OpenTelemetry para observar herramientas, coste, errores, duración y comportamiento de sesión.

Crear control de costes con límites de turnos, presupuestos, reporting y alertas de consumo anómalo.

Diseñar sandboxing, aislamiento, gestión de credenciales y reglas de egress para producción.

Preparar pipeline CI/CD para tests, revisión de seguridad, empaquetado y despliegue controlado.

Crear suite de evaluación con tareas de prueba, casos límite, prompt injection, errores de herramienta y regresión.

Optimizar latencia, coste, tamaño de contexto, fan-out de subagentes y uso de herramientas.

Preparar dashboard operativo con métricas, logs, trazas, errores, costes y sesiones activas.

Documentar runbook de operación: despliegue, rollback, troubleshooting, revocación y soporte.

Redactar política de uso y matriz de permisos para el agente final.

Presentar informe de riesgos con mitigaciones: seguridad, datos, permisos, costes, calidad y dependencia tecnológica.

Defender la solución ante un comité técnico simulando preguntas de arquitectura, seguridad, negocio y operación.

Entregar repositorio final con código, prompts, configuración, tests, documentación, guía de despliegue y roadmap de evolución.