⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
anatomia-cc
ES: Te dice qué construir en Claude Code y te da el esqueleto de archivos: skill y en qué modo, subagente, hook, servidor MCP, plugin, rutina, artefacto, app con el Agent SDK, una línea en CLAUDE.md, o nada. Corré esto antes del primer archivo. Se dispara con «esto lo hago como skill o como agente», «necesito un MCP o alcanza con una skill», «va como comando o como skill», «quiero que esto salga como una pantalla para mandarle a alguien y no como texto en la terminal», «quiero meter Claude adent
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
El problema
Abrís Claude Code y hay skills, subagentes, comandos, plugins, servidores MCP, hooks, canales, rutinas y artefactos. Nueve palabras, ninguna explicada, y una decisión que hay que tomar en el minuto uno.
Lo más común es armar un subagente para algo que era un archivo de texto, o un servidor MCP para algo que resolvía un script de veinte líneas.
El costo no se ve el primer día. Se ve al mes, cuando la sesión arranca pesada, el modelo elige mal seguido, y nadie se acuerda de por qué esa carpeta está ahí.
Qué hace
Corre cuatro pasos sobre tu caso y devuelve una pieza, con el motivo en una frase y el árbol de archivos listo para completar.
Y hace algo que casi ninguna guía hace: empieza preguntando si hace falta
construir algo. Buena parte de los casos se resuelven con una línea en el
CLAUDE.md, instalando algo que ya existe, o con un script de veinte líneas.
Cuando la respuesta es esa, lo dice.
vos › quiero revisar cuarenta archivos buscando problemas de seguridad
y que me traiga solo los hallazgos
skill › Paso 2, pregunta 2.4 → es una SKILL, con `context: fork`.
Corre en un subagente, así que los cuarenta archivos no entran
a tu conversación.
No hace falta escribir un subagente aparte: aislar el contexto
dejó de ser un archivo y pasó a ser una línea del frontmatter.
revision-de-seguridad/
SKILL.md
references/
Dónde funciona
En los tres lados, con el mismo archivo: el .zip del Release.
| Dónde | Cómo se instala | Cuánto tarda |
|---|---|---|
| Claude Code — terminal, VS Code, JetBrains, escritorio, web | Dos comandos, o el .zip | Un minuto |
| App de Claude — chat en web, escritorio y celular | Subís el .zip en Customize | Un minuto |
| Cowork y sesiones en la nube — incluidas las rutinas | Se habilita desde tu cuenta | Ya está, si la subiste al chat |
Que ande fuera de Claude Code no es casualidad. Las skills siguen el estándar
abierto Agent Skills, que admite seis campos en el
frontmatter. Claude Code acepta bastantes más —context: fork,
disable-model-invocation, argument-hint— pero cualquiera de ésos hace fallar
la subida a claude.ai con un error duro, no lo ignora. Esta skill usa cuatro
campos y los cuatro están en el estándar, y el cuerpo no tiene nada exclusivo de
Claude Code: ni $ARGUMENTS, ni ${CLAUDE_SKILL_DIR}, ni comandos embebidos.
Instalación
En Claude Code
Como plugin, sin descargar nada:
/plugin marketplace add Hainrixz/claude-anatomy
/plugin install claude-anatomy@claude-anatomy
O con el .zip del último Release:
mkdir -p .claude/skills
unzip anatomia-cc-*.zip -d .claude/skills/
Eso la deja en el proyecto. Para tenerla en todos, descomprimila en la carpeta de skills de tu configuración de usuario. La ruta de proyecto es reversible y la de usuario no: por eso el default es proyecto.
También podés clonar el repo y copiar la carpeta a mano:
git clone https://github.com/Hainrixz/claude-anatomy
mkdir -p .claude/skills
cp -R claude-anatomy/skills/anatomia-cc .claude/skills/
En la app de Claude
Sirve el mismo .zip, sin tocar nada.
- Descargá
anatomia-cc-*.zipdel último Release. - En la app, andá a Customize → Skills.
- Tocá +, después Crear skill, y después Subir una skill.
- Elegí el
.zip. Listo.
Anda en los planes Free, Pro, Max, Team y Enterprise, siempre que tengas la ejecución de código habilitada.
En Cowork y en las sesiones en la nube
No hay un paso aparte: Cowork usa las skills habilitadas en tu cuenta de claude.ai, así que con subirla al chat una vez ya la tenés en los dos. Se administran desde Customize en la barra lateral de la app de escritorio, o desde la configuración de skills en claude.ai. Se sincronizan al arrancar la sesión.
La trampa que hace perder una tarde. Cowork, las sesiones en la nube y las rutinas no leen la carpeta de skills de tu máquina. Si la instalaste solo ahí, una rutina que la invoque va a decir que la skill no existe, porque cada corrida arranca como una sesión remota nueva. Para que la vean: habilitala en tu cuenta de claude.ai, o —si es una sesión en la nube sobre un repo— commiteala en el
.claude/skills/de ese repo.Las tareas programadas del escritorio son la excepción: corren en tu máquina y leen lo mismo que cualquier sesión local.
Por qué la skill se llama anatomia-cc y el repo claude-anatomy
No es un descuido. Las superficies alojadas por Anthropic —la subida a
claude.ai, Cowork y la Skills API— rechazan un name que contenga «claude» o
«anthropic», en cualquier posición. Es una reserva de marca: sirve para que
ninguna skill de terceros pueda hacerse pasar por oficial.
Claude Code no aplica esa regla, así que la primera versión de esta skill se
llamaba claude-anatomy y funcionaba perfecto ahí… y no subía a la app. El
nombre del repo, el del plugin y los comandos de instalación no tienen esa
restricción y por eso siguen igual.
Dos consecuencias prácticas para vos, si estás por publicar una skill:
- El
namedel frontmatter y el nombre de la carpeta tienen que coincidir. Eso lo pide la Skills API, no Claude Code: acá elnamees solo la etiqueta y el comando sale del nombre de la carpeta. Si renombrás la carpeta en Claude Code, la skill sigue cargando y lo que cambia es el comando. - El validador oficial
quick_validate.pyno detecta la palabra reservada. Empaqueta contento y el rechazo aparece recién al subir.
Qué cambia en cada lado
En Claude Code te da la recomendación y el esqueleto de archivos, y seguís de largo construyendo ahí mismo.
En la app y en Cowork te da la recomendación y el esqueleto como texto: te sirve para decidir y para entender, y después vas a Claude Code a construirlo. Sigue teniendo sentido, porque la duda —«¿esto es una skill o un agente?»— suele aparecer antes de abrir la terminal.
Cómo se usa
Se activa sola. Escribí lo que escribirías igual:
- «esto lo hago como skill o como agente?»
- «necesito un MCP o alcanza con una skill»
- «esto va como slash command o como skill?»
- «quiero que esto salga como una pantalla que le pueda mandar a alguien»
- «quiero meter esto adentro de mi app»
- «por dónde empiezo»
También dispara en inglés, con «should I build this as a skill or an agent».
El árbol de decisión
Cuatro pasos. Adentro de cada uno, la primera pregunta que da «sí» cierra ese paso.
%%{init: {"theme":"base","themeVariables":{"lineColor":"#C8542E","primaryColor":"#FBF1E8","primaryTextColor":"#161210","primaryBorderColor":"#E9C9AE","edgeLabelBackground":"#FBF1E8","font
// HOW IT'S BUILT
// FILES
18 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/anatomia-cc/SKILL.md13 KBb87b74ec82f9upstream ↗
--- name: anatomia-cc description: "ES: Te dice qué construir en Claude Code y te da el esqueleto de archivos: skill y en qué modo, subagente, hook, servidor MCP, plugin, rutina, artefacto, app con el Agent SDK, una línea en CLAUDE.md, o nada. Corré esto antes del primer archivo. Se dispara con «esto lo hago como skill o como agente», «necesito un MCP o alcanza con una skill», «va como comando o como skill», «quiero que esto salga como una pantalla para mandarle a alguien y no como texto en la terminal», «quiero meter Claude adentro de mi app», «quiero que corra solo todas las noches» o «por dónde empiezo». EN: Tells you what to build in Claude Code and hands you the file skeleton: skill and mode, subagent, hook, MCP server, plugin, routine, artifact, Agent SDK app, a CLAUDE.md line, or nothing. Triggers on «skill or agent», «do I need an MCP», «slash command or skill», «I want this as a page I can send someone, not terminal text», «I want Claude inside my app», «run it nightly on its own», «where do I start»." license: MIT metadata: version: 0.3.1 --- <!-- Copyright (c) 2026 Enrique Rocha (@soyenriquerocha) · tododeia.com · id er-b2159f46 --> # Anatomía de Claude Code ## El dolor Abrís Claude Code y hay skills, subagentes, comandos, plugins, servidores MCP, hooks, canales, rutinas y artefactos. Nueve palabras, ninguna explicada, y una decisión que hay que tomar en el minuto uno. Lo más común es armar un subagente para algo que era un archivo de texto, o un servidor MCP para algo que resolvía un script de veinte líneas. El costo no se ve el primer día. Se ve al mes, cuando la sesión arranca pesada, el modelo elige mal seguido, y nadie se acuerda de por qué esa carpeta está ahí. Este archivo no enseña a escribir cada pieza. Enseña a elegir cuál. ## Cuándo usar esto Al empezar cualquier proyecto, antes del primer archivo. Y cada vez que dudás entre dos formas para la misma idea. También sirve para el caso que casi nadie contempla: que la respuesta correcta sea que no hay que construir nada. ## Las tres preguntas que más rinden Con estas tres alcanza para la mayoría de los casos, sin recorrer el árbol entero. ``` 1. ¿Quién aprieta el botón? Vos, escribiendo /algo · el modelo, cuando aparece el tema · un evento de Claude Code · el reloj · un sistema de afuera · nadie, es una regla que Claude tiene que saber siempre. 2. ¿Toca algo de afuera que pida su propia credencial? Una base, una API, la cuenta de un servicio. 3. Cuando termina, ¿qué queda y quién lo mira? Texto en tu terminal · una pantalla que alguien abre en el navegador · archivos cambiados en el repo · una respuesta que consume otro programa. ``` La tercera es la que más se olvida, y es la que decide si esto vive adentro de una sesión o no. ## Paso 0 · ¿Hace falta construir algo? Cuatro preguntas. La primera que da sí termina acá. ``` 0.1 ¿Lo que falta es que Claude se acuerde de una regla tuya? «usá pnpm, no npm» · «corré los tests antes de commitear» SÍ → No construyas ninguna pieza: es una línea en CLAUDE.md. Si la regla aplica solo a ciertos archivos, va en .claude/rules/ con `paths:`, y entra nada más cuando Claude toca esos archivos. 0.2 ¿Ya lo hizo otro? GitHub, Slack, Postgres, Notion y Sentry ya tienen servidor MCP. Y hay plugins publicados para buena parte del resto. SÍ → No construyas nada. Instalalo. 0.3 ¿Lo que te molesta es CÓMO te contesta, no lo que sabe? Querés otro tono, más explicación, que siempre arranque con un diagrama. SÍ → No es una skill: es un estilo de salida, en .claude/output-styles/. Ojo, se lee una vez al arrancar: aplica después de /clear. 0.4 ¿Lo resuelve un script, sin modelo adentro? Si siempre se hace igual y no hay nada que decidir, es un script. SÍ → Escribilo. Claude lo corre con Bash cuando haga falta. NO → seguí al Paso 1. ``` Buena parte de los casos que llegan hasta acá se resuelven en este paso. No es una broma: la pieza más chica que resuelve el problema es casi siempre la correcta, y siempre es la más fácil de tirar cuando te equivocaste. ## Paso 1 · ¿Adentro de una sesión, o afuera? Tres preguntas. La primera que da sí termina acá. ``` 1.1 ¿Lo que se entrega es una pantalla que alguien mira o comparte —un tablero, un informe con gráficos, un diff anotado— y no texto en la terminal? SÍ → Artefacto: una página que Claude publica desde la sesión y actualiza en el mismo link. El límite, antes de que te ilusiones: es UNA página sin backend. No guarda formularios y no tiene rutas. Si necesitás eso, es una app y la hospedás vos. 1.2 ¿Lo va a usar gente que nunca abre Claude Code, desde tu web o tu producto? SÍ → App con el Agent SDK, en Python o TypeScript. 1.3 ¿Tiene que correr con tu computadora apagada? Cada noche, cada lunes. SÍ → Rutina en la nube, con /schedule. Corre sobre un clon limpio y no lee tus skills locales: habilitalas en tu cuenta de claude.ai, o que viajen en el repo o en un plugin. NO → seguí al Paso 2. ``` Si alguna dio sí, el detalle está en `references/afuera-de-la-sesion.md`. ## Paso 2 · Qué pieza Cuatro preguntas. La primera que da sí fija la pieza. ``` 2.1 ¿Tiene que pasar SIEMPRE, sin que el modelo decida? Formatear después de cada edición. Frenar un comando peligroso. SÍ → Hook. Una instrucción escrita es un pedido; el hook es la única forma de garantizarlo. 2.2 ¿Necesita entrar a un sistema de afuera con su propia credencial? SÍ → Servidor MCP. Si además hay criterio que aplicar sobre lo que trae, arriba va una skill: son dos piezas, y el MCP va primero. Si el sistema de afuera tiene que EMPUJAR el evento hacia adentro de una sesión abierta, eso es un canal. 2.3 ¿Es un trabajador reusable, con herramientas recortadas, al que vas a llamar por su nombre desde varios lugares? SÍ → Subagente propio, en .claude/agents/nombre.md. Dato que decide muchos casos: un subagente no te puede preguntar nada a mitad de camino. 2.4 Lo que queda es una SKILL. Falta el modo, que está acá abajo. ``` ## Los cuatro modos de una skill Acá está el cambio que más desactualiza al material viejo: **el comando dejó de ser una pieza aparte y pasó a ser un campo del frontmatter de la skill.** Un archivo en `.claude/commands/deploy.md` y una skill en `.claude/skills/deploy/SKILL.md` producen los dos el mismo `/deploy`. El subagente **sigue siendo una pieza aparte**, con su archivo y su carpeta. Lo que cambió es otra cosa y conviene no confundirla: una skill ahora puede correr adentro de un subagente con `context: fork`, sin que tengas que escribirle uno propio. El subagente propio se justifica cuando además es reusable. | | La disparás vos | La dispara el modelo | Las dos | |---|---|---|---| | **Corre en tu conversación** | `disable-model-invocation: true` | `user-invocable: false` | el default | | **Corre aparte** | `disable-model-invocation: true` + `context: fork` | `user-invocable: false` + `context: fork` | `context: fork` | `context: fork` decide **dónde** corre, no **quién** la dispara. Sola no la saca del menú de `/`: para eso hace falta `user-invocable: false`. Son dos ejes distintos y se combinan. - **`disable-model-invocation: true`** es lo que antes era un comando. Va para cosas con consecuencias: desplegar, commitear, mandar mensajes. Regalo extra: no ocupa contexto hasta que la invocás. - **`user-invocable: false`** es conocimiento de fondo. Claude debería saberlo cuando el tema aparece, pero no es nada que alguien quiera tipear. - **`context: fork`** corre la skill en un subagente. Solo sirve si la skill trae una tarea; si es solo conocimiento, el subagente vuelve con las manos vacías. El detalle, y el precio de usar campos que no están en el estándar, en `references/modos-de-skill.md`. ## Paso 3 · ¿Se empaqueta? Esto se contesta siempre, al final, después de saber qué pieza es. ``` 3.1 ¿Te salieron dos o más piezas que se instalan juntas o no sirven? ¿O lo mismo tiene que andar en otro repo, o en la máquina de otra persona? SÍ → Plugin. Y si además vas a repartir varios, arriba va un marketplace: un marketplace.json en un repo de git. NO → Dejalo suelto en .claude/. Un plugin de una sola pieza que usás solo vos es un manifiesto de más. ``` ## Qué carga contexto y qué no Casi todas las piezas pueden hacer casi lo mismo. Lo que las separa es qué te cobran y cuándo. | Pieza | En el turno cero | Después | |---|---|---| | `CLAUDE.md` | Entero, siempre | — | | `.claude/rules/` con `paths:` | Nada | Cuando Claude toca esos archivos | | Skill | Una línea de descripción | El cuerpo al disparar, y ahí se queda | | Skill con `disable-model-invocation` | Nada | Todo, al invocarla vos | | Servidor MCP | Los nombres de las herramientas | El esquema, cuando se usa | | Subagente | Nada en tu ventana | Corre en la suya y te devuelve el resumen | | Hook | Nada | Solo el `additionalContext` que devuelva | Tres cosas que casi nadie sabe. **Una skill que cargó se queda cargada** el resto de la sesión, así que un `SKILL.md` con seis casos adentro te cobra los seis aunque hoy uses uno. **La búsqueda de herramientas difiere los esquemas de MCP**, así que el viejo consejo de no instalar servidores porque comen contexto hoy se dice distinto: lo que empeora con cuarenta herramientas no es el gasto, es la elección. Y **el `stdout` suelto de un hook no entra al contexto**: va al log de depuración. Lo que Claude lee es lo que el hook devuelva en `hookSpecificOutput.additionalContext`. Todo esto se mide, no se estima: `/context` te muestra en qué se está yendo la ventana ahora mismo. Está desarrollado en `references/como-se-carga-el-contexto.md`. ## Los anti-patrones más comunes | Anti-patrón | Qué hacer en su lugar | |---|---| | Un comando de barra para algo nuevo | Skill con `disable-model-invocation` | | Un subagente aparte solo para aislar contexto | `context: fork` en la skill que ya tenías | | Un MCP con cuarenta herramientas por las dudas | Las operaciones que alguien pidió | | Una skill que pide una clave de API | MCP abajo, skill de criterio arriba | | Un plugin con una sola skill que usás solo vos | Dejala suelta | | Un hook que decide con criterio | Hook para la regla fija, skill para el juicio | | Una regla importante escrita en el `CLAUDE.md` | Si tiene que valer siempre, es un hook | | Un `CLAUDE.md` de ochocientas líneas | Lo que aplica a veces va en skills | | Un `SKILL.md` de tres mil palabras con seis casos | Cuerpo corto y un archivo por caso | | `context: fork` en una skill que solo sabe cosas | El default, o `user-invocable: false` | | Pedir un artefacto esperando una app | Si guarda datos, la hospedás vos | Los once con el antes y el después están en `references/anti-patrones.md`. ## Qué entregás ``` 1. La pieza recomendada, una sola, con el motivo en una frase y el número de la pregunta que la decidió. Si es una skill, también el modo. 2. El árbol de archivos de esa pieza, copiado del assets/ que corresponde y ya nombrado con el caso concreto. 3. Si el caso reparte en dos piezas, cuál se construye primero y por qué. 4. Lo que NO hace falta construir. Si alguien vino a pedir un plugin y se va con una línea en CLAUDE.md, eso se dice. ``` ## Material de apoyo Leé el que corresponda al caso, no todos. | Archivo | Cuándo | |---|---| | `references/como-se-carga-el-contexto.md` | Hay que comparar el costo de dos formas | | `references/modos-de-skill.md` | La respuesta fue skill y falta el modo | | `references/mcp-o-skill.md` | La skill que pensabas empezó a pedir una credencial | | `references/afuera-de-la-sesion.md` | El Paso 1 dio sí | | `references/anti-patrones.md` | Querés el antes y el después de un caso | | `assets/arbol-de-decision.md` | El árbol entero en una página, para copiar | | `assets/esqueleto-skill.md` | La respuesta fue skill o estilo de salida | | `assets/esqueleto-subagente.md` | La respuesta fue subagente | | `assets/esqueleto-hook.md` | La respuesta fue hook | | `assets/esqueleto-mcp.md` | La respuesta fue servidor MCP o canal | | `assets/esqueleto-plugin.md` | Hay que empaquetar, o repartir | | `assets/esqueleto-artefacto.md` | La respuesta fue artefacto | | `assets/esqueleto-app-sdk.md` | La respuesta fue app con el SDK | | `assets/esqueleto-rutina.md` | Tiene que correr solo, cada tanto | ## Lo que esto no hace No escribe la pieza entera. Entrega la recomendación y el esqueleto. Si la pieza elegida es una skill, la escribe `skill-smith`. No reemplaza la documentación oficial, que cambia seguido. Esta guía se escribió contra la documentación de agosto de 2026 y conviene verificar contra la de hoy lo que vayas a apoyar en un número. No decide si conviene automatizar algo. Esa pregunta es anterior: acá se asume que ya decidiste construir, y falta la forma.skills/anatomia-cc/references/afuera-de-la-sesion.md4.3 KB391571923003upstream ↗
# Cuando lo que querés no vive adentro de una sesión ## De qué se trata este archivo Las piezas clásicas —skill, subagente, hook, MCP— comparten un supuesto: hay una persona con Claude Code abierto, escribiendo. A veces no. A veces lo que hace falta es una pantalla que alguien abre en el navegador, o Claude adentro de un producto que usa gente que no tiene Claude Code, o algo que corre a las tres de la mañana. Eso es lo que hay acá. ## Una pantalla para que alguien mire Es un artefacto: una página que Claude publica desde la sesión, con su link, que se actualiza en el mismo lugar cada vez que se republica. Sirve cuando el resultado se entiende mejor mirándolo que leyéndolo. Un diff anotado, un tablero, cuatro maquetas al lado de la otra. Es **una página sola y sin backend**. No guarda formularios, no tiene rutas, y para traer datos de afuera solo puede llamar conectores MCP. Si necesitás más que eso, no es un artefacto: es una aplicación. El detalle en `assets/esqueleto-artefacto.md`. ## Claude adentro de tu producto Es el Agent SDK: Claude Code como librería, en Python o TypeScript. Desde otro lenguaje se corre la CLI con `-p` y `--output-format json`. Carga tu `.claude/` igual que Claude Code, así que las skills y los subagentes que ya escribiste andan adentro sin reescribirlos. Por eso conviene probar la idea como skill primero. Dos cosas que cambian todo: se paga con una clave de API, y los permisos los decide tu código porque no hay nadie mirando. El detalle en `assets/esqueleto-app-sdk.md`. ## Que corra solo Tres formas, y la elección sale de una pregunta: ¿tiene que correr con tu máquina apagada? Sí, es una rutina en la nube. No, y la sesión puede estar cerrada, es una tarea del escritorio. No, y alcanza con que corra mientras trabajás, es `/loop`. La trampa de la rutina: corre sobre un clon limpio y **no lee la carpeta de skills de tu máquina**. Hay tres salidas: habilitar la skill en tu cuenta de claude.ai, commitearla en el `.claude/skills/` del repo, o mandarla en un plugin declarado en el `.claude/settings.json` del repo. El detalle en `assets/esqueleto-rutina.md`. ## Cuando son demasiados subagentes Un subagente resuelve una tarea aparte. Tres subagentes también. Cuando son cincuenta, y tienen que revisarse entre ellos, y el plan de quién hace qué no entra en una ventana de contexto, eso es un workflow: un script que orquesta subagentes, con el plan escrito afuera del contexto en vez de adentro. No hay carpeta que armar para correrlo la primera vez: se le pide a Claude que escriba el script, que es JavaScript. Si el resultado sirve, se guarda en `.claude/workflows/` y queda para reusar. ## Cuando el evento viene de afuera Todo lo anterior asume que la sesión pregunta. Existe la dirección contraria: que el CI que falló, o el mensaje que llegó, entren solos a una sesión que ya está abierta. Eso es un canal. Por debajo es un servidor MCP que declara la capacidad `claude/channel`; lo que cambia es para qué lado va la flecha. Vale la pena saber que existe, sobre todo para no escribir un `/loop` que consulta cada cinco minutos algo que podría avisar solo. ## Tres que conviene mirar antes de apoyarte en ellas **Los equipos de agentes** —varias sesiones coordinadas— son experimentales y vienen apagados: se prenden con `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`. Construir algo que dependa de eso hoy es construir sobre algo que puede cambiar. **Los mensajes entre sesiones** son otra cosa, y conviene no meterlos en la misma bolsa: ya vienen **prendidos** en macOS y Linux, sin configurar nada. O sea que la pregunta no es cómo activarlos sino si querés apagarlos. **Los canales** están en vista previa. Y hay un detalle que hace perder una tarde: que tu servidor declare la capacidad **no alcanza**. Tiene que estar nombrado en `--channels` al arrancar la sesión, y mientras dure la vista previa un canal propio ni siquiera entra por ahí sin una bandera de desarrollo. Si armás el MCP y no llega ningún evento, es esto. ## La pregunta que ordena todo esto Cuando termina, ¿qué queda y quién lo mira? - Texto en tu terminal, para vos → una pieza de las clásicas. - Una pantalla que alguien abre → artefacto. - Una respuesta que consume otro programa → app con el SDK. - Nada, porque nadie estaba mirando → rutina.skills/anatomia-cc/references/anti-patrones.md5.9 KB6d35e46afc0dupstream ↗
# Los once anti-patrones Todos salen de lo mismo: elegir la pieza por lo que suena importante en vez de por quién la dispara y qué carga. Convención de este archivo: **lo que falla va en bloque de código, lo que se corrige va en cita.** ## 1. Armar un comando de barra para algo nuevo ``` .claude/commands/revisar-pr.md ``` Los comandos se fusionaron con las skills. El archivo sigue funcionando y no hay que migrar nada, pero para algo nuevo no es la puerta de entrada. > Una skill con `disable-model-invocation: true` hace exactamente lo mismo: > la disparás vos con `/revisar-pr` y el modelo no la usa por su cuenta. Y encima > te deja colgarle `references/` y `scripts/`, que un `.md` suelto no tiene. ## 2. Escribir un subagente aparte solo para aislar contexto ``` .claude/agents/revisor-de-archivos.md ``` Escrito porque la tarea lee cuarenta archivos y no queríamos ese ruido en la conversación principal. Ese motivo ya no alcanza. > El aislamiento hoy es un campo. `context: fork` en la skill que ya tenías la > corre en un subagente sin que exista un segundo archivo que mantener. > > El subagente propio se justifica cuando es un trabajador reusable, con > herramientas recortadas, al que llaman por su nombre desde varios lugares. ## 3. Un servidor MCP con cuarenta herramientas por las dudas ``` listar_usuarios, crear_usuario, editar_usuario, borrar_usuario, listar_pedidos, crear_pedido, editar_pedido, borrar_pedido, ... ``` Envolver la API entera porque «alguna vez puede servir». > El motivo por el que esto está mal cambió, así que vale aclararlo: antes se > decía que los esquemas te comían el contexto en cada turno. Hoy la búsqueda de > herramientas los difiere, así que ese costo ya casi no aplica. > > Lo que sí queda es que el modelo elige peor entre cuarenta nombres parecidos > que entre seis. Expone las operaciones que alguien pidió. Y si querés el > número real de tu máquina, `/context` lo mide. ## 4. Una skill que pide una clave de API ```markdown Para consultar los tickets usá SOPORTE_API_KEY=sk_live_a1b2... ``` Publica la credencial, y además no anda: el modelo no hace un pedido HTTP porque se lo diga un archivo de texto. > Son dos piezas. El servidor MCP expone `listar_tickets_abiertos()` y guarda la > credencial de su lado. La skill se queda con el criterio de priorización y no > menciona ninguna clave. ## 5. Un plugin con una sola skill adentro que usás solo vos ``` mi-plugin/ ├── .claude-plugin/plugin.json └── skills/ └── revisar-pr/SKILL.md ``` `agents/`, `commands/` y `hooks/` vacías. > Dejala suelta en `.claude/skills/revisar-pr/`. El manifiesto no suma nada > todavía. > > El plugin se gana el lugar cuando hay dos o más piezas que se instalan juntas, > o cuando lo mismo tiene que andar en otra máquina. ## 6. Un hook que tiene que decidir con criterio ```json { "matcher": "Bash", "hooks": [{ "type": "command", "command": "./es-peligroso.sh" }] } ``` Con un script que intenta adivinar si el comando es riesgoso mirando la línea. > El hook no pasa por el modelo, y eso es justo lo que lo hace útil. Pero si > «peligroso» depende del contexto, el script fijo va a fallar en silencio en los > casos raros, que son los que importan. > > La regla fija va en el hook —`rm -rf` se bloquea siempre— y el criterio va en > una skill. Si de verdad necesitás juicio adentro del hook, existen los tipos > `prompt` y `agent`, pero pensá primero si eso no era una skill. ## 7. Una regla importante escrita en el CLAUDE.md ```markdown IMPORTANTE: nunca hagas commit sin correr los tests. ``` Se cumple casi siempre. «Casi siempre» es exactamente el problema cuando lo que está en juego es publicar algo. > Una instrucción escrita es un pedido. Si tiene que valer todas las veces, es un > hook de `PreToolUse`, que es la única pieza que no depende del criterio del > modelo. ## 8. Un CLAUDE.md de ochocientas líneas Con la historia del proyecto, las convenciones de seis lenguajes y el detalle de tres integraciones. Entra entero en cada sesión, hable de lo que hable la conversación de hoy. > Dejá en el `CLAUDE.md` lo que aplica siempre, y que sea corto. > > Lo que aplica a veces va en skills, que entran cuando el tema aparece. Y lo que > aplica a ciertos archivos va en `.claude/rules/` con `paths:`, que entra > solamente cuando Claude toca esos archivos. ## 9. Un SKILL.md de tres mil palabras con seis casos adentro ```markdown ## Proveedor A ...400 palabras... ## Proveedor B ...400 palabras... ## Proveedor C ``` > Una skill que cargó se queda cargada el resto de la sesión. Con seis casos > adentro pagás los seis aunque el de hoy sea uno. > > El cuerpo lleva el procedimiento y la tabla de cuál es cuál. Cada caso se va a > un archivo en `references/`, y el cuerpo dice cuándo leer cada uno. ## 10. `context: fork` en una skill que solo sabe cosas ```yaml --- name: convenciones-de-tests context: fork --- Usá describe/it. Un assert por test. Nombres en español. ``` > El subagente arranca, recibe pautas, no tiene ninguna tarea que hacer con > ellas, y vuelve sin nada. > > `context: fork` es para skills con instrucciones ejecutables. Para conocimiento > va el default, o `user-invocable: false` si además no querés que salga en el > menú de `/`. ## 11. Pedir un artefacto esperando una aplicación ``` Armá un artefacto donde el equipo cargue las horas y queden guardadas. ``` > El artefacto es una página sola y sin backend: no guarda lo que alguien > escriba en un formulario, no tiene varias rutas y no autentica a nadie. > > Para mostrar, comparar o anotar, sirve. Para guardar datos, es una aplicación y > la hospedás vos. ## Lo que tienen en común En diez de los once, la pieza elegida era más grande que el problema. Ese es el sesgo por defecto y conviene tenerlo presente: ante la duda, la pieza más chica que resuelve el caso es casi siempre la correcta, y siempre es la más fácil de tirar cuando te equivocaste.skills/anatomia-cc/references/como-se-carga-el-contexto.md4.4 KB858f3968312aupstream ↗
# Qué entra al contexto, y cuándo ## Por qué importa para elegir la pieza Casi todas las piezas pueden hacer casi lo mismo. Lo que las separa de verdad es qué te cobran y cuándo te lo cobran. Una sesión que arranca con medio contexto ocupado no falla: se pone tonta más temprano. Elegís mal la pieza el día uno y lo pagás al mes, cuando ya nadie se acuerda de por qué esa carpeta está ahí. ## El turno cero, en orden Esto es lo que ya está adentro antes de que escribas la primera palabra. | Orden | Qué entra | Cuánto pesa | |---|---|---| | 1 | El prompt de sistema | Fijo, no lo ves | | 2 | La memoria automática, `MEMORY.md` | Las primeras 200 líneas o 25 KB, lo que llegue antes | | 3 | Datos del entorno: carpeta, sistema, shell, si es un repo | Poco | | 4 | Los **nombres** de las herramientas MCP | Poco: los esquemas quedan diferidos | | 5 | Una línea de descripción por cada skill instalada | Poco por skill, y se suma | | 6 | Tu `CLAUDE.md` de usuario | Entero | | 7 | El `CLAUDE.md` del proyecto | Entero | Recién después entra lo que escribiste vos. ## Lo que no entra hasta que hace falta - **El cuerpo de una skill.** Entra cuando la skill dispara, no antes. Sus `references/` y `assets/` entran solo si el cuerpo manda a leerlos. - **Los esquemas de las herramientas MCP.** Por defecto, la búsqueda de herramientas los deja diferidos y trae solo los que la tarea pide. - **El prompt de un subagente.** Entra en la ventana del subagente, no en la tuya. - **Un hook.** Su definición no entra nunca. Los tipos `command`, `http` y `mcp_tool` no pasan por el modelo en absoluto; `prompt` y `agent` sí, porque son una llamada al modelo disfrazada de hook. ## Las tres consecuencias que deciden casi todo **Una skill que ya cargó se queda cargada.** No se descarga al terminar el tema. Por eso un `SKILL.md` de tres mil palabras que cubre seis casos te cobra los seis aunque el de hoy sea uno. La salida no es escribir menos: es partir el cuerpo del material de apoyo. **El subagente es la única pieza que trabaja sin gastarte contexto.** Corre en su ventana, lee cuarenta archivos si hace falta, y te devuelve el resumen. Los cuarenta archivos no entran a tu conversación. A cambio no te puede preguntar nada a mitad de camino. **Un hook cuesta cero mientras no diga nada.** Y acá hay una trampa que hace perder una tarde: lo que el hook imprima por salida estándar **no entra al contexto**, va al log de depuración. Las excepciones son `UserPromptSubmit`, `UserPromptExpansion` y `SessionStart`. Si querés que Claude lea algo que produjo el hook, el hook tiene que devolverlo en `hookSpecificOutput.additionalContext`. Un `PostToolUse` con un `echo` adentro, esperando que el modelo lo lea, no le llega a nadie. ## Lo que cambió con el MCP, y que conviene desaprender Durante un tiempo el consejo fue: no instales muchos servidores MCP porque los esquemas de sus herramientas te comen el contexto en cada turno. Hoy eso ya no describe el comportamiento por defecto. La búsqueda de herramientas viene prendida y difiere los esquemas: al arranque entran los nombres, y el esquema completo llega cuando alguna herramienta se va a usar de verdad. El costo que sí sigue existiendo es otro, y es de calidad, no de tokens. Entre cuarenta nombres parecidos el modelo elige peor que entre seis. Un servidor con herramientas «por las dudas» sigue siendo mala idea, pero por esto y no por lo otro. Y no hace falta que nadie te lo estime: `/context` te muestra en qué se está yendo la ventana, desglosado, y `/mcp` te muestra el estado y las herramientas de cada servidor. Medilo en tu máquina antes de discutirlo. ## Después de `/compact` La lista de descripciones de skills no se vuelve a inyectar. Se conservan las skills que efectivamente se usaron. Una skill marcada con `disable-model-invocation: true` no aparece en esa lista ni siquiera al arrancar: se queda afuera del contexto hasta que vos escribís `/nombre`. Es la forma más barata que hay de tener una skill instalada. ## Cómo verificar todo esto vos mismo - `/context` te muestra en qué se está yendo la ventana ahora mismo. - `/mcp` te muestra el estado y las herramientas de cada servidor. - La documentación tiene una simulación paso a paso del arranque de una sesión, en la página «Explore the context window». Estos números cambian entre versiones. Lo que no cambia es el orden de las preguntas: quién lo dispara, qué carga, y cuándo.skills/anatomia-cc/references/mcp-o-skill.md3.3 KB5998e15a7774upstream ↗
# Servidor MCP o skill ## La señal es la credencial No hace falta pensarlo mucho. Si mientras escribís el `SKILL.md` aparece un token, una clave de API o un usuario y contraseña, la decisión ya está tomada: eso es un servidor MCP. Una skill es un archivo de texto que el modelo lee. Meter una credencial adentro es publicarla: viaja en el repo, entra al contexto y queda en la transcripción. ## El caso típico, en las dos versiones Alguien quiere que Claude priorice los tickets de soporte abiertos. Así **no**: ```markdown --- name: triaje-de-soporte --- Para ver los tickets, llamá a la API con este token: SOPORTE_API_KEY=sk_live_a1b2c3... GET https://api.soporte.com/v1/tickets?estado=abierto ``` Además de publicar la clave, no funciona: el modelo no puede hacer un pedido HTTP porque se lo diga un archivo de texto. Así **sí**, en dos piezas: > **El servidor MCP** expone dos operaciones: `listar_tickets_abiertos()` y > `ver_ticket(id)`. La credencial vive en una variable de entorno, del lado del > servidor. El modelo nunca la ve. > > **La skill** no menciona ninguna clave. Trae el criterio: qué hace que un > ticket sea urgente, cómo se agrupan los repetidos, qué se responde primero y > por qué. Es el reparto que más se repite en la práctica. El MCP trae los datos, la skill trae el juicio. ## Cuándo alcanza con la skill sola Cuando lo que hay que procesar ya está en la conversación. Si pegaste el texto, si el archivo está en el repo, si los datos ya los trajo otra cosa: no hay sistema externo, no hay credencial, no hay MCP. Es una skill y listo. ## Cuándo alcanza con el MCP solo Cuando la operación es mecánica y no hay nada que decidir. «Traeme el estado del pedido 4821» no necesita criterio. Una herramienta que consulta y devuelve alcanza. Escribir una skill encima para explicar cómo leer un número de pedido es trabajo que nadie va a leer. ## Antes de escribir un servidor, fijate si ya existe GitHub, Slack, Postgres, Notion, Sentry, Linear, Figma y varios más ya tienen su servidor MCP, mantenido por alguien que no sos vos. Escribir el propio se justifica cuando el sistema es tuyo, o cuando es interno, o cuando el que existe expone cuarenta operaciones y vos necesitás tres. ## Lo que ya no es cierto sobre el costo Antes se decía que cada servidor MCP conectado te cobraba los esquemas de todas sus herramientas en cada turno, y de ahí salía el consejo de instalar pocos. Hoy la búsqueda de herramientas viene prendida por defecto y difiere los esquemas: al arranque entran los nombres y el esquema llega cuando la herramienta se va a usar. El costo que sí queda es de precisión. Entre cuarenta nombres parecidos el modelo elige peor que entre seis. Así que la regla práctica sobrevive —exponé lo que alguien pidió, no lo que la API tiene— pero el motivo cambió. Si querés el número de tu máquina en vez de una opinión, `/context` te muestra en qué se está yendo la ventana, y `/mcp` cuántas herramientas expone cada servidor. ## La pregunta que resuelve el noventa por ciento ¿Esto necesita entrar a algún lado con una credencial propia? Sí, es MCP. No, es skill. Y si además hay criterio que aplicar sobre lo que el MCP trae, son las dos, y el MCP se construye primero: la skill sin él no tiene qué llamar.skills/anatomia-cc/references/modos-de-skill.md6.2 KBcd6f76201aaeupstream ↗
# Los modos de una skill ## Lo que cambió, y por qué importa Durante mucho tiempo esto eran tres piezas distintas: la skill que el modelo usaba solo, el comando de barra que escribías vos, y el subagente que corría aparte para no llenarte el contexto. Hoy son una pieza con tres perillas. Los comandos se fusionaron con las skills. Un archivo en `.claude/commands/deploy.md` y una skill en `.claude/skills/deploy/SKILL.md` producen los dos el mismo `/deploy` y funcionan igual. Los comandos que ya tenías escritos siguen andando y no hay que migrar nada. Para algo nuevo conviene la skill, porque además admite archivos de apoyo. Y el aislamiento de contexto —lo único que antes obligaba a escribir un subagente aparte— ahora es un campo del frontmatter. Si venís de material escrito hace unos meses, esto es lo primero que hay que corregir. ## Las dos preguntas que fijan el modo **¿Quién la dispara?** Vos escribiendo `/nombre`, o el modelo cuando aparece el tema. **¿Dónde corre?** En tu conversación, o en una ventana aparte. | | La disparás vos | La dispara el modelo | Las dos | |---|---|---|---| | **Corre en tu conversación** | `disable-model-invocation: true` | `user-invocable: false` | el default: no escribís nada | | **Corre aparte** | `disable-model-invocation: true` + `context: fork` | `context: fork` | `context: fork` | Los cuatro casos, dichos en criollo: - **El default.** Ni escribís nada ni pasa nada raro. Vos la podés invocar y el modelo también. - **`disable-model-invocation: true`.** Solo vos. Es lo que antes era un comando. Va para cosas con consecuencias: desplegar, commitear, mandar un mensaje. No querés que el modelo decida que hoy es buen día para desplegar. Regalo extra: no ocupa contexto hasta que la invocás. - **`user-invocable: false`.** Solo el modelo. Va para conocimiento de fondo que no es una acción. «Cómo funciona el sistema viejo de facturación» es algo que Claude debería saber cuando el tema aparece, pero `/sistema-viejo` no es nada que alguien quiera tipear. - **`context: fork`.** Corre en un subagente. Sirve cuando la tarea genera mucho ruido intermedio que a vos no te sirve: leer cuarenta archivos y traer tres hallazgos. ## Cuándo `context: fork` no sirve Solo sirve si la skill trae una tarea que ejecutar. Si la skill es «seguí estas convenciones al escribir tests», el subagente recibe las pautas, no tiene nada que hacer con ellas, y vuelve con las manos vacías. Para conocimiento va el default, o `user-invocable: false`. La regla corta: `context: fork` para skills con instrucciones ejecutables, nunca para skills que solo saben algo. ## El campo `agent`, y la dirección inversa Con `context: fork` podés elegir en qué tipo de subagente corre, con `agent:`. Y existe el camino inverso: un subagente puede declarar `skills:` para precargar skills al arrancar. Ojo con esto, porque es al revés de lo que pasa en una sesión normal: ahí se precarga el **contenido completo** de la skill, no la descripción. ## Todos los campos Claude Code acepta todos estos en el frontmatter de un `SKILL.md`: | Campo | Para qué | |---|---| | `name` | En Claude Code es opcional: por defecto toma el nombre de la carpeta. En el estándar abierto es obligatorio | | `description` | Recomendado, no obligatorio: sin él se usa el primer párrafo del cuerpo. Es lo que hace que dispare, y se corta a los 1.536 caracteres | | `when_to_use` | Frases y ejemplos que ayudan a disparar. Se suma a `description` y comparte ese mismo tope | | `argument-hint` | Qué argumentos espera, para el autocompletado | | `arguments` | Nombres de los argumentos, para usarlos como `$nombre` | | `disable-model-invocation` | Solo la disparás vos | | `user-invocable` | En `false`, solo la dispara el modelo | | `allowed-tools` | Herramientas que no piden permiso durante ese turno | | `disallowed-tools` | Herramientas que se sacan durante ese turno. Vuelven con tu próximo mensaje | | `model` | Con qué modelo corre | | `effort` | Nivel de esfuerzo mientras está activa | | `context` | En `fork`, corre en un subagente | | `agent` | Qué tipo de subagente, si hay `context: fork` | | `background` | Solo aplica con `context: fork`. Por defecto `true`, o sea segundo plano; en `false` esperás el resultado en el mismo turno | | `hooks` | Hooks atados al ciclo de vida de esta skill | | `paths` | Patrones que limitan cuándo se activa sola, como las reglas por ruta | | `shell` | `bash` o `powershell`, para los comandos embebidos | | `metadata` | Datos tuyos. Claude Code no los mira | | `license` | La licencia | | `compatibility` | Requisitos del entorno. Hasta 500 caracteres | Sustituciones que podés usar en el cuerpo: `$ARGUMENTS`, `$0` para el primer argumento, `$1` para el segundo, `$nombre` para los declarados en `arguments`, más `${CLAUDE_SKILL_DIR}` y `${CLAUDE_PROJECT_DIR}`. ## El precio de usar los campos extra Acá hay un cruce que conviene saber antes y no después. Las skills siguen un estándar abierto que admite **seis** campos: `name`, `description`, `license`, `compatibility`, `metadata` y `allowed-tools`. Todo lo demás es una extensión de Claude Code. Mientras la skill viva en Claude Code, usá lo que quieras. Pero si la vas a subir a claude.ai, usarla por la API de Skills o empaquetarla con las herramientas del estándar, cualquier campo de más falla con un mensaje de este tipo: ``` Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, name ``` La decisión, en una línea: si la skill tiene que viajar, seis campos; si es tuya y vive en Claude Code, usá todo. Un detalle que sorprende: `version` **no** es uno de los seis. Va adentro de `metadata`, así: ```yaml metadata: version: 0.2.0 ``` ## De dónde sale el nombre del comando En una skill tuya o de proyecto, el comando sale del **nombre de la carpeta**. El campo `name` es solo la etiqueta que se muestra en los listados. En una skill que viene adentro de un plugin es distinto: ahí `name` fija el último tramo, y el prefijo del plugin se mantiene. `mi-plugin/skills/revisar/SKILL.md` con `name: fancy` se invoca como `/mi-plugin:fancy`. Por eso conviene que la carpeta y el `name` digan lo mismo. Cuando no coinciden, el que se equivoca sos vos dentro de tres meses.skills/anatomia-cc/assets/arbol-de-decision.md5.0 KBbb841f9003bbupstream ↗
# El árbol de decisión, en una página Para imprimir, pegar en un canal, o tener al lado mientras arrancás un proyecto. Cuatro pasos. Adentro de cada uno, la primera pregunta que da sí cierra ese paso. El Paso 3 se contesta siempre, al final. ## Las tres preguntas que más rinden ``` 1. ¿Quién aprieta el botón? Vos, escribiendo /algo · el modelo, cuando aparece el tema · un evento de Claude Code · el reloj · un sistema de afuera · nadie, es una regla que Claude tiene que saber siempre. 2. ¿Toca algo de afuera que pida su propia credencial? Una base, una API, la cuenta de un servicio. 3. Cuando termina, ¿qué queda y quién lo mira? Texto en tu terminal · una pantalla que alguien abre en el navegador · archivos cambiados en el repo · una respuesta que consume otro programa. ``` ## El árbol ``` PASO 0 · ¿HACE FALTA CONSTRUIR ALGO? 0.1 ¿Es que Claude se acuerde de una regla tuya? SI -> CLAUDE.md NO -> sigue 0.2 ¿Ya lo hizo otro? SI -> instalalo NO -> sigue 0.3 ¿Te molesta CÓMO contesta, no lo que sabe? SI -> estilo de salida NO -> sigue 0.4 ¿Lo resuelve un script, sin modelo adentro? SI -> script NO -> PASO 1 PASO 1 · ¿ADENTRO DE UNA SESIÓN, O AFUERA? 1.1 ¿Se entrega una pantalla que alguien mira? SI -> artefacto NO -> sigue 1.2 ¿Lo usa gente que no abre Claude Code? SI -> app, Agent SDK NO -> sigue 1.3 ¿Corre con tu computadora apagada? SI -> rutina en la nube NO -> PASO 2 PASO 2 · QUÉ PIEZA 2.1 ¿Tiene que pasar SIEMPRE, sin criterio? SI -> hook NO -> sigue 2.2 ¿Entra a un sistema con credencial propia? SI -> servidor MCP NO -> sigue 2.3 ¿Es un trabajador reusable, con nombre? SI -> subagente NO -> sigue 2.4 Lo que queda -> SKILL (elegí el modo) PASO 3 · ¿SE EMPAQUETA? (siempre, al final) 3.1 ¿Dos o más piezas que viajan juntas? SI -> plugin ¿O tiene que andar en otra máquina? (+ marketplace si lo repartís) NO -> dejalo suelto ``` ## Los cuatro modos de una skill | | La disparás vos | La dispara el modelo | Las dos | |---|---|---|---| | **En tu conversación** | `disable-model-invocation: true` | `user-invocable: false` | el default | | **Aparte** | `disable-model-invocation: true` + `context: fork` | `user-invocable: false` + `context: fork` | `context: fork` | `context: fork` decide dónde corre, no quién la dispara: sola no la saca del menú de `/`. Son dos ejes distintos y se combinan. ## Dónde vive cada pieza | Pieza | Se dispara por | Vive en | |---|---|---| | `CLAUDE.md` | Siempre está | `CLAUDE.md` en la raíz | | Regla con `paths:` | Claude toca esos archivos | `.claude/rules/nombre.md` | | Estilo de salida | Lo elegís con `/config` | `.claude/output-styles/nombre.md` | | Skill | El tema aparece, o `/nombre` | `.claude/skills/nombre/SKILL.md` | | Subagente | El hilo principal delega | `.claude/agents/nombre.md` | | Hook | Un evento de Claude Code | `.claude/settings.json` | | Servidor MCP | El modelo llama una herramienta | `.mcp.json` | | Canal (vista previa) | Un sistema de afuera empuja | Un MCP con `claude/channel`, arrancado con `--channels` | | Plugin | Se instala como paquete | `.claude-plugin/plugin.json` | | Marketplace | Se agrega una vez | `.claude-plugin/marketplace.json` | | Artefacto | Lo publica la sesión | Un link de claude.ai | | Rutina | El reloj | Se arma con `/schedule` | | App | Tu programa lo llama | Tu repo, con el Agent SDK | ## Lo que no está en el árbol y conviene saber **Workflow.** Cuando en vez de tres subagentes necesitás cincuenta y que se revisen entre ellos. Es un script que orquesta y guarda el plan afuera del contexto. **Equipos de agentes.** Varias sesiones coordinadas. Es experimental y viene apagado: se prende con `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`. No conviene apoyar nada en eso todavía. **Mensajes entre sesiones.** Esto es distinto y conviene no confundirlo: ya viene **prendido** en macOS y Linux, sin configurar nada. Se apaga, no se prende. **Canales.** Están en vista previa. Declarar la capacidad no alcanza: el servidor tiene que nombrarse en `--channels` al arrancar, y uno propio todavía no entra por ahí sin una bandera de desarrollo.skills/anatomia-cc/assets/esqueleto-app-sdk.md2.5 KB16ee95bd73aaupstream ↗
# Esqueleto: app con el Agent SDK Esto es para cuando lo que querés construir lo va a usar gente que nunca va a abrir Claude Code. Un botón en tu producto, un endpoint de tu backend, un bot. El Agent SDK es Claude Code como librería adentro de tu programa: las mismas herramientas, el mismo bucle, y vos manejás los permisos y la orquestación. ## En Python ``` {{mi-app}}/ ├── app.py ├── requirements.txt ├── .env ← ANTHROPIC_API_KEY, y no se versiona. │ El SDK NO lo lee solo: exportá la variable, │ o cargalo vos con python-dotenv └── .claude/ ├── skills/ ← el SDK las carga igual que Claude Code └── agents/ ``` ```python import asyncio from claude_agent_sdk import query async def main(): async for mensaje in query(prompt="{{lo que tiene que hacer}}"): print(mensaje) asyncio.run(main()) ``` ## En TypeScript ``` {{mi-app}}/ ├── src/index.ts ├── package.json ├── .env └── .claude/ ``` ```typescript import { query } from "@anthropic-ai/claude-agent-sdk"; for await (const mensaje of query({ prompt: "{{lo que tiene que hacer}}" })) { console.log(mensaje); } ``` ## Desde otro lenguaje El SDK es Python y TypeScript. Desde Go, Ruby, PHP o lo que uses, se llama la CLI y se lee la salida como JSON: ```bash claude -p "{{la tarea}}" --output-format json ``` Es menos cómodo y alcanza para la mayoría de los casos. ## Lo que hay que saber antes de arrancar **Se paga con una clave de API, no con tu suscripción.** Anthropic no permite que un producto de terceros ofrezca iniciar sesión con una cuenta de claude.ai. Tu app usa su propia clave y vos pagás el consumo. **Carga tu `.claude/`.** Las skills y los subagentes que ya escribiste andan adentro de la app, sin reescribir nada. Eso hace que valga la pena probar la idea primero como skill y recién después envolverla. **Los permisos los definís vos.** No hay una persona mirando y aprobando. Lo que en Claude Code te pregunta, acá lo decide tu código. Es la diferencia más importante y es donde se cometen los errores caros. ## Antes de escribir la primera línea Preguntate si de verdad hace falta la app. Si el que lo va a usar sos vos, o tu equipo, y todos tienen Claude Code, una skill hace lo mismo y no hay que mantener un servidor, ni rotar una clave, ni cobrar el consumo. La app se justifica cuando el que lo usa **no** tiene Claude Code y no lo va a tener.skills/anatomia-cc/assets/esqueleto-artefacto.md3.1 KBc07fa5e35a60upstream ↗
# Esqueleto: artefacto Acá no hay carpeta que armar. Un artefacto no es un archivo que escribís: es una página que Claude publica desde la sesión, en un link de claude.ai que se abre en el navegador. Lo que se arma es el pedido. ## Cómo se pide ``` Armá un artefacto que {{muestre esto}}, con {{esta forma}}. ``` Ejemplos que funcionan: ``` Armá un artefacto que recorra este PR con el diff anotado al lado de cada hallazgo, y que marque la severidad con color. ``` ``` Hacé un tablero de los deploys que fallaron la semana pasada, por servicio, y actualizalo mientras investigás. ``` Claude escribe un `.html` o un `.md` en tu proyecto, pide permiso una vez, y lo publica. Te imprime la URL. Para cambiarlo, se lo pedís y republica **en el mismo link**. Quien lo tenga abierto ve el cambio. Cada publicación queda como una versión. Desde otra sesión, le pasás la URL. Sin la URL, crea uno nuevo en vez de actualizar el que ya existe. ## Los límites, antes de que te ilusiones Es una página sola y sin backend. En concreto: | Límite | Qué significa | |---|---| | Una sola página | Los links relativos no resuelven. Las secciones van con anclas | | Sin backend | No guarda lo que alguien escriba en un formulario, ni autentica a nadie | | Sin pedidos a otros servidores | Todo va embebido: el CSS, el JavaScript, las imágenes | | Tipos de archivo | `.html`, `.htm` o `.md` | | Tamaño | Hasta 16 MiB ya renderizado | Si necesitás guardar datos, tener varias rutas o que alguien inicie sesión, eso no es un artefacto: es una aplicación y la hospedás vos. ## Datos que se actualizan Un artefacto puede llamar conectores MCP cada vez que alguien lo abre, así la página muestra datos de hoy y no una foto del día que se armó. ``` Armá un tablero de los PR abiertos que traiga la lista en vivo por mi conector de GitHub cuando se carga la página. ``` Tres cosas que conviene saber antes de prometerle esto a alguien: - Cada persona que lo abre usa **sus** conectores, no los tuyos. Dos personas pueden ver datos distintos en la misma página. - A cada visitante se le pide permiso la primera vez. - Los servidores MCP locales tuyos —los de `.mcp.json`— sirven para armar la página, pero la página publicada no los puede llamar. Y una que sorprende: un artefacto que llama conectores **no** se puede compartir por link público. ## Qué hace falta para que ande Tres cosas a la vez: plan Pro, Max, Team o Enterprise —y en Enterprise, con los artefactos habilitados por un Owner—; la sesión iniciada con `/login`; y que el proveedor sea la API de Anthropic. Sobre Bedrock, Google Cloud o Microsoft Foundry no hay artefactos. Una sesión que corre con una clave de API tampoco puede publicarlos. Si Claude escribe el `.html` local y no te da ningún link, es esto: la sesión no cumple alguna de esas condiciones. ## Cuándo conviene de verdad Cuando lo que salió es más fácil de mirar que de leer. Un diff anotado, un gráfico, cuatro maquetas para comparar, una línea de tiempo que se va llenando mientras corre algo largo. Si la salida es texto que se lee bien en la terminal, el artefacto es una vuelta de más.skills/anatomia-cc/assets/esqueleto-hook.md2.9 KB204cd1e9ecddupstream ↗
# Esqueleto: hook ``` .claude/ ├── settings.json ← acá se declara └── hooks/ └── {{tarea}}.sh ← acá vive el script ``` ## El mínimo que anda ```json { "hooks": { "PostToolUse": [ { "matcher": "Edit", "hooks": [ { "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/formatear.sh" } ] } ] } } ``` `matcher` filtra por nombre de herramienta. Si lo omitís, engancha con todo. ## Los eventos que más se usan | Evento | Cuándo dispara | |---|---| | `PreToolUse` | Antes de una herramienta. El lugar habitual para negarla | | `PostToolUse` | Después. Para formatear, para revisar lo que quedó | | `UserPromptSubmit` | Cuando mandás un mensaje | | `SessionStart` | Al arrancar la sesión | | `SessionEnd` | Al cerrarla | | `Stop` | Cuando Claude termina de responder | | `SubagentStop` | Cuando termina un subagente | | `PreCompact` | Antes de compactar el contexto | | `FileChanged` | Cuando cambia un archivo | | `Notification` | Cuando Claude Code te avisa algo | Hay más de treinta en total. Estos son los que cubren la mayoría de los casos reales; el resto está en la referencia de hooks de la documentación. ## Los tipos de handler No todo hook es un script de shell. Son cinco: | Tipo | Qué hace | |---|---| | `command` | Corre un comando | | `http` | Pega a una URL | | `mcp_tool` | Llama una herramienta de un servidor MCP | | `prompt` | Le pregunta a un modelo | | `agent` | Despacha un subagente | Los últimos dos existen justamente para el caso en que hace falta criterio. Pero si el criterio es el corazón del asunto y no una excepción, mirá primero si eso no era una skill. ## Bloquear algo, de verdad Un `PreToolUse` puede negar la operación. El script decide y contesta por salida estándar: ```bash #!/bin/bash COMANDO=$(jq -r '.tool_input.command') if echo "$COMANDO" | grep -q 'rm -rf'; then jq -n '{ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: "Comando destructivo frenado por un hook" } }' else exit 0 fi ``` ## La razón de fondo para elegir un hook Una instrucción escrita en un `CLAUDE.md` o en una skill es un **pedido**. Se cumple casi siempre, y «casi siempre» es exactamente el problema cuando lo que está en juego es borrar algo o publicar algo. Un hook no pasa por el criterio del modelo. Es la única forma de garantizar que algo pase todas las veces. El costo de esa garantía es que no razona. Si lo que define «peligroso» depende del caso, un script fijo va a fallar en silencio en los casos raros. Ahí la regla fija va en el hook y el criterio va en una skill. ## Lo que cuesta Nada, mientras no diga nada. El hook corre afuera del modelo. Si imprime algo para que Claude lo lea, eso sí entra al contexto.skills/anatomia-cc/assets/esqueleto-mcp.md3.3 KB4d4d50877708upstream ↗
# Esqueleto: servidor MCP Un servidor MCP casi nunca se escribe desde cero. Los servicios conocidos —GitHub, Slack, Postgres, Sentry, Notion— ya tienen el suyo. Lo que se arma primero es la **conexión**. ## Conectar uno que ya existe ```bash claude mcp add --transport http {{nombre}} https://{{servidor}}/mcp claude mcp add --env API_KEY=... --transport stdio {{nombre}} -- {{comando}} ``` Lo mismo escrito a mano, en `.mcp.json` en la raíz del proyecto: ```json { "mcpServers": { "{{nombre}}": { "command": "{{comando}}", "args": ["{{argumento}}"], "env": { "{{VARIABLE}}": "${{{VARIABLE}}}" } } } } ``` **El envoltorio `mcpServers` va siempre.** En el `.mcp.json` del proyecto y en el de un plugin, los dos. Sin él, el servidor no carga. Una entrada con `url` y sin `type` es un error de configuración: Claude Code la lee como si fuera un servidor por stdio y la saltea. ## Los transportes | Transporte | Cuándo | |---|---| | `stdio` | Corre como proceso local en tu máquina. Para lo que necesita tocar el disco | | `http` | Servidores remotos. Es el recomendado. Acepta el alias `streamable-http` | | `sse` | Obsoleto. Solo si el servicio no expone otra cosa | | `ws` | Conexión persistente en las dos direcciones. Sin OAuth | ## Las credenciales Nunca adentro del `.mcp.json` que se versiona. Van por variable de entorno, y el repo lleva un `env.example` con los nombres y sin los valores: ``` {{SERVICIO}}_API_KEY= {{SERVICIO}}_URL= ``` ## Si lo vas a escribir vos ``` {{nombre}}-mcp/ ├── servidor/ │ ├── servidor.py ← el proceso que habla el protocolo │ └── tools.py ← una función por operación ├── .mcp.json ├── env.example └── pruebas/ ``` Dos reglas que ahorran disgustos: **Exponé las operaciones que alguien pidió, no las que la API tiene.** Envolver cuarenta endpoints «por las dudas» no cuesta tokens como costaba antes —los esquemas quedan diferidos— pero sí empeora la elección: entre cuarenta nombres parecidos el modelo acierta menos que entre seis. **Separá lo que consulta de lo que escribe.** Y que lo que escribe pida confirmación. ## Si el sistema de afuera tiene que empujar Todo lo de arriba es Claude llamando hacia afuera. Existe la dirección contraria: que el sistema externo meta un evento adentro de una sesión abierta —el CI que falló, el mensaje que llegó— y Claude reaccione. Eso es un canal, y está en vista previa. Es un servidor MCP por stdio que declara la capacidad `claude/channel`. La pieza es la misma; lo que cambia es para qué lado va la flecha. **Declararla no alcanza.** El servidor tiene que estar nombrado en `--channels` al arrancar la sesión, y mientras dure la vista previa un canal propio no está en la lista aprobada: para probarlo local hace falta una bandera de desarrollo. Si armaste el servidor y no llega ningún evento, es esto y no tu código. ## Adentro de un plugin El `.mcp.json` va en la raíz del plugin, con el mismo envoltorio, y las rutas se escriben con `${CLAUDE_PLUGIN_ROOT}`: ```json { "mcpServers": { "{{nombre}}": { "command": "${CLAUDE_PLUGIN_ROOT}/servidor/servidor.py" } } } ``` Una ruta relativa ahí adentro se resuelve contra la carpeta de trabajo del que instala, que no es donde está el plugin. Anda en tu máquina y falla en la de al lado.skills/anatomia-cc/assets/esqueleto-plugin.md3.0 KBbe323c28b3a0upstream ↗
# Esqueleto: plugin ``` {{nombre-del-plugin}}/ ├── .claude-plugin/ │ ├── plugin.json ← el manifiesto │ └── marketplace.json ← solo si el repo se reparte solo ├── skills/ │ └── {{nombre}}/SKILL.md ├── agents/ │ └── {{nombre}}.md ├── commands/ ← formato viejo, sigue andando ├── hooks/ │ └── hooks.json └── .mcp.json ``` Dos reglas de ubicación que rompen el plugin si se equivocan: **El manifiesto va adentro de `.claude-plugin/`.** Un `plugin.json` suelto en la raíz no lo lee nadie. **Las piezas van en la raíz, no adentro de `.claude-plugin/`.** Esa carpeta lleva manifiestos, nada más. ## El manifiesto mínimo ```json { "name": "{{nombre-del-plugin}}", "version": "0.1.0", "description": "{{Qué trae adentro}}", "license": "MIT" } ``` `name` es el único campo obligatorio, y de hecho el `plugin.json` entero es opcional: sin él, Claude Code descubre las piezas por las carpetas. Igual conviene tenerlo, porque es lo que te deja versionar. ## Si adentro va un servidor MCP ```json { "mcpServers": { "{{nombre}}": { "command": "${CLAUDE_PLUGIN_ROOT}/servidor/servidor.py" } } } ``` El envoltorio `mcpServers` va **siempre**, tanto en el `.mcp.json` de la raíz del plugin como en el del proyecto. Y toda ruta se escribe con `${CLAUDE_PLUGIN_ROOT}`: una ruta relativa se resuelve contra la carpeta de trabajo del que instala, que no es donde quedó el plugin. ## Lo que un subagente pierde al entrar a un plugin `hooks`, `mcpServers` y `permissionMode` se ignoran para subagentes que vienen adentro de un plugin. Lo escribís suelto, anda, lo empaquetás, y deja de respetar los permisos sin avisar. ## Repartirlo Un plugin instalado a mano no necesita nada más. Para que otros lo instalen con un comando, hace falta un marketplace: un `marketplace.json` en un repo de git. Si el repo tiene un solo plugin y es el repo mismo: ```json { "name": "{{nombre-del-repo}}", "owner": { "name": "{{usuario}}", "url": "https://github.com/{{usuario}}" }, "plugins": [ { "name": "{{nombre-del-plugin}}", "source": "./", "version": "0.1.0", "description": "{{Qué trae adentro}}", "license": "MIT" } ] } ``` Y se instala así: ``` /plugin marketplace add {{usuario}}/{{nombre-del-repo}} /plugin install {{nombre-del-plugin}}@{{nombre-del-repo}} ``` `source: "./"` quiere decir «el plugin es este mismo repo». Si en cambio el marketplace es un índice que apunta a varios repos, cada entrada lleva la URL del repo de destino. ## Cuándo el plugin todavía no hace falta Si `skills/` tiene una sola entrada y `agents/`, `commands/` y `hooks/` están vacías, el manifiesto no está sumando nada sobre dejar la skill suelta en `.claude/skills/`. El plugin se gana el lugar cuando hay dos o más piezas que se instalan juntas o no sirven, o cuando lo mismo tiene que andar en otro repo o en la máquina de otra persona.skills/anatomia-cc/assets/esqueleto-rutina.md2.4 KBf9a5267a3dc5upstream ↗
# Esqueleto: que corra solo, cada tanto Tampoco hay carpeta acá. Lo que hay es elegir cuál de las tres formas es la tuya, y esa elección la define una sola pregunta: **¿tiene que correr con tu computadora apagada?** ## Las tres formas | | Rutina en la nube | Tarea del escritorio | `/loop` | |---|---|---|---| | Dónde corre | En la nube | En tu máquina | En tu máquina | | ¿La compu prendida? | No hace falta | Sí | Sí | | ¿La sesión abierta? | No hace falta | No hace falta | Sí | | ¿Ve tus archivos? | No: clona el repo de nuevo | Sí | Sí | | Intervalo mínimo | 1 hora | 1 minuto | 1 minuto | ## Rutina en la nube Se arma con `/schedule`. Sirve para el resumen de los lunes, la revisión de los PR de la noche, la auditoría semanal de dependencias. El detalle que hace perder una tarde: **la rutina no ve tus skills personales.** Arranca como una sesión nueva sobre un clon limpio del repo. Lo que tengas en la carpeta de skills de tu configuración de usuario no existe ahí. Si la rutina necesita una skill, la skill tiene que viajar: - adentro del repo, en `.claude/skills/`, o - adentro de un plugin declarado en `.claude/settings.json` Los servidores MCP también se configuran por rutina, no se heredan. ## Tarea del escritorio Se programa desde la app de escritorio. Corre en tu máquina, así que ve tus archivos y tus herramientas locales, y baja hasta un minuto de intervalo. El precio es que la máquina tiene que estar prendida. ## `/loop` Para mirar algo mientras estás trabajando. Un deploy que está corriendo, un PR que espera revisión. ``` /loop 5m fijate si terminó el deploy y contame qué pasó ``` Sin intervalo, Claude elige cuánto esperar según lo que vio: menos si hay movimiento, más si está todo quieto. ``` /loop fijate si pasó el CI y respondé los comentarios de la revisión ``` Vive adentro de la sesión. Si cerrás la conversación, se termina. Y vence a los siete días. ## Antes de programar nada Dos preguntas que ahorran la pieza entera. **¿Es un intervalo, o es un evento?** Si lo que querés es reaccionar cuando pasa algo —el CI falló, llegó un mensaje— consultar cada cinco minutos es la forma cara de enterarse. Eso es un canal: el sistema de afuera empuja el evento adentro de la sesión. **¿Hace falta un modelo?** Si la tarea siempre se hace igual y no hay nada que decidir, un cron con un script cuesta menos y falla menos.skills/anatomia-cc/assets/esqueleto-skill.md3.2 KBc46cfb61ff6eupstream ↗
# Esqueleto: skill ``` {{nombre-de-la-skill}}/ ├── SKILL.md ← lo único obligatorio ├── references/ ← se lee solo si el cuerpo manda a leerlo │ └── {{tema}}.md ├── assets/ ← se copia, no se lee │ └── {{plantilla}}.md └── scripts/ ← se ejecuta, no se lee └── {{tarea}}.py ``` La carpeta va en `.claude/skills/` del proyecto, o en la carpeta de skills de tu configuración de usuario si la querés en todas partes. El nombre de la carpeta es el comando. Si la carpeta se llama `revisar-pr`, se invoca con `/revisar-pr`. ## El mínimo que anda ```markdown --- name: {{nombre-de-la-skill}} description: "ES: {{qué hace}}. Usala cuando {{frase real 1}}, {{frase real 2}} o {{frase real 3}}. EN: {{the same}}." metadata: version: 0.1.0 --- # {{Título}} ## El dolor {{Qué se rompe hoy, en dos o tres frases.}} ## Cuándo usar esto {{En qué momento entra, con las señales concretas.}} ## Procedimiento 1. {{Paso}} 2. {{Paso}} ## Qué entregás {{La salida, en una lista corta.}} ``` ## Las cuatro variantes Cambia una línea del frontmatter, cambia quién la dispara y dónde corre. **Que la dispare solo el modelo, cuando aparece el tema.** No agregues nada. Es el default. **Que la dispares solo vos.** Para cosas con consecuencias: desplegar, commitear, mandar mensajes. ```yaml disable-model-invocation: true ``` **Que la use solo el modelo, sin salir en el menú de `/`.** Para conocimiento de fondo que no es una acción. ```yaml user-invocable: false ``` **Que corra en un subagente, para no llenarte el contexto.** Solo sirve si la skill trae una tarea concreta. ```yaml context: fork agent: Explore ``` Ojo: estos tres campos son extensiones de Claude Code. Si la skill tiene que viajar a claude.ai o a la API, el estándar admite seis campos y ninguno de estos está adentro. Está explicado en `references/modos-de-skill.md`. ## Si venís de un comando de barra Un archivo en `.claude/commands/desplegar.md` sigue funcionando y no hay que tocarlo. Si lo querés pasar a skill: ``` .claude/commands/desplegar.md → .claude/skills/desplegar/SKILL.md ``` Mudarlo tal cual ya funciona igual. Lo que ganás es la carpeta: ahora podés colgarle `references/` y `scripts/`. Y si querés que solo lo dispares vos —que es lo que la gente suele dar por sentado de un comando— agregale `disable-model-invocation: true`. ## Si lo que querías era cambiar el tono, no el conocimiento Eso no es una skill: es un estilo de salida. Es un `.md` con frontmatter que va en `.claude/output-styles/` del proyecto, o en la carpeta equivalente de tu configuración de usuario. ```markdown --- name: {{Nombre visible}} description: {{Qué cambia en la respuesta}} keep-coding-instructions: true --- {{Las instrucciones que se suman al prompt de sistema.}} ``` Se elige con `/config`. Y hay un detalle que hace perder tiempo: el estilo es parte del prompt de sistema, que se lee una sola vez al arrancar. El cambio aplica después de `/clear` o en la sesión siguiente, no en el momento. ## Para escribir la skill completa Este archivo da el árbol, no el contenido. Para que alguien la escriba entera, con la descripción que dispara y las pruebas, está la skill `skill-smith`.skills/anatomia-cc/assets/esqueleto-subagente.md3.1 KBb47ba3ca402cupstream ↗
# Esqueleto: subagente ``` .claude/ └── agents/ └── {{nombre}}.md ``` Un archivo, nada más. Va en `agents/` del proyecto, o en la carpeta equivalente de tu configuración de usuario si lo querés en todas partes. ## El mínimo que anda ```markdown --- name: {{nombre}} description: {{Cuándo el hilo principal tiene que delegarle a este}} tools: Read, Grep, Glob model: inherit color: cyan --- Sos {{el rol}}. {{Las instrucciones. Es un prompt de sistema entero: el subagente no ve tu conversación, así que acá va todo lo que necesita saber.}} Devolvé {{la forma exacta de la salida}}. ``` ## Los campos, y sus valores válidos | Campo | Valores | |---|---| | `name` | Obligatorio. Minúsculas y guiones. No puede llevar `:` | | `description` | Obligatorio. Es lo que decide cuándo se le delega | | `tools` | Las que puede usar. Si lo omitís, hereda todas | | `disallowedTools` | Las que se le sacan | | `model` | `sonnet`, `opus`, `haiku`, `fable`, un id completo, o `inherit` | | `color` | `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, `cyan` | | `permissionMode` | `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions`, `plan`, y `manual` como alias de `default` | | `maxTurns` | Cuántos turnos antes de frenar | | `skills` | Skills que se precargan enteras al arrancar | | `memory` | `user`, `project` o `local`, para que aprenda entre sesiones | | `background` | En `true`, siempre corre en segundo plano | | `isolation` | En `worktree`, corre sobre una copia aislada del repo | Dos que se equivocan seguido: `color` no acepta `magenta`, y `model` por defecto es `inherit`, no el modelo más caro. ## Lo que un subagente no puede hacer **No te puede preguntar nada.** La herramienta de hacer preguntas no existe adentro de un subagente. Si el trabajo necesita ida y vuelta con una persona, esa parte se queda en el hilo principal. **No ve tu conversación.** Arranca limpio. Todo lo que necesite saber va en su prompt. **Corriendo en segundo plano tiene menos herramientas.** Y ese es el default. Si tu subagente necesita una herramienta que no está en el conjunto reducido, pedile a Claude que lo corra en primer plano. ## Si el subagente viaja adentro de un plugin Tres campos se ignoran: `hooks`, `mcpServers` y `permissionMode`. Esto muerde así: lo escribís suelto, anda, lo metés en un plugin, y deja de respetar los permisos sin decir nada. Si dependés de esos tres, el subagente se queda suelto. ## Cuando no alcanza con uno Si en vez de tres subagentes necesitás cincuenta, que se revisen entre ellos y que el plan sobreviva a la ventana de contexto, eso ya no es un subagente suelto: es un workflow, que es un script que orquesta subagentes y guarda el plan afuera del contexto. ## Antes de escribir esto, una pregunta Si lo único que querés es que una tarea corra aparte para no llenarte el contexto, no hace falta un subagente propio. Le ponés `context: fork` a la skill que ya tenías. El subagente propio se justifica cuando es un trabajador reusable, con herramientas recortadas, al que van a llamar por su nombre desde varios lugares.skills/anatomia-cc/evals/decisiones.json6.4 KB29b2871433eaupstream ↗
{ "skill_name": "anatomia-cc", "tipo": "decision", "nota": "Un set de disparo mide si la skill se activa. No distingue un árbol correcto de uno que contesta «subagente» a todo. Estos 12 casos miden la RESPUESTA: una pieza por rama, y las que no hay que construir.", "umbral": "10 de 12. Un caso que recomienda una pieza de más cuenta como error aunque la pieza nombrada sea razonable.", "casos": [ { "id": "D01", "caso": "Quiero que Claude siempre use pnpm en este repo y que corra los tests antes de commitear.", "esperado": { "paso": "0.1", "pieza": "claude-md", "esqueleto": null, "no_construir": ["skill", "hook", "plugin"], "segunda_pieza": null, "nota": "El pedido tiene dos mitades y solo una es CLAUDE.md. «Correr los tests antes de commitear» es una garantía, así que si la persona insiste en que valga siempre, esa mitad es un hook. Se acepta la respuesta que separa las dos." } }, { "id": "D02", "caso": "Necesito que nadie, ni Claude, pueda editar el archivo .env de este proyecto. Nunca.", "esperado": { "paso": "2.1", "pieza": "hook", "esqueleto": "assets/esqueleto-hook.md", "no_construir": ["claude-md", "skill"], "segunda_pieza": null, "nota": "La palabra «nunca» es la señal. Una instrucción escrita es un pedido; el hook es la garantía." } }, { "id": "D03", "caso": "Tengo un checklist de deploy de doce pasos que pego a mano cada vez. No quiero que Claude lo dispare solo por las dudas.", "esperado": { "paso": "2.4", "pieza": "skill", "modo": "disable-model-invocation: true", "esqueleto": "assets/esqueleto-skill.md", "no_construir": ["comando", "subagente"], "segunda_pieza": null, "nota": "No vale recomendar un comando de barra. Es el anti-patrón 1." } }, { "id": "D04", "caso": "Quiero revisar cuarenta archivos buscando problemas de seguridad y que me traiga solo los hallazgos, sin llenarme la conversación con el contenido de los archivos.", "esperado": { "paso": "2.4", "pieza": "skill", "modo": "context: fork", "esqueleto": "assets/esqueleto-skill.md", "no_construir": ["subagente"], "segunda_pieza": null, "nota": "Este es el caso de regresión de toda la versión 0.2.0. La respuesta vieja era «subagente» y hoy está mal: aislar contexto es un campo del frontmatter, no un archivo aparte." } }, { "id": "D05", "caso": "Necesito un revisor de código con acceso de solo lectura, con instrucciones propias, al que llamen por su nombre tres skills distintas y también yo.", "esperado": { "paso": "2.3", "pieza": "subagente", "esqueleto": "assets/esqueleto-subagente.md", "no_construir": [], "segunda_pieza": null, "nota": "Acá sí es un subagente propio: reusable, con herramientas recortadas, llamado por nombre desde varios lugares. Es el contraste de D04." } }, { "id": "D06", "caso": "Quiero que Claude lea los tickets de nuestro sistema interno, que tiene API con token, y que me diga cuáles atender primero.", "esperado": { "paso": "2.2", "pieza": "mcp", "esqueleto": "assets/esqueleto-mcp.md", "no_construir": [], "segunda_pieza": "skill", "orden": "el MCP primero: la skill sin él no tiene qué llamar", "nota": "Reparte en dos. Fallar acá es devolver una sola pieza." } }, { "id": "D07", "caso": "Hay un sistema de facturación viejo que nadie entiende. Quiero que Claude sepa cómo funciona cuando el tema aparezca, pero no es nada que yo vaya a invocar.", "esperado": { "paso": "2.4", "pieza": "skill", "modo": "user-invocable: false", "esqueleto": "assets/esqueleto-skill.md", "no_construir": ["claude-md"], "segunda_pieza": null, "nota": "No vale meterlo en el CLAUDE.md: entraría entero en cada sesión aunque el tema no aparezca nunca." } }, { "id": "D08", "caso": "Quiero un tablero con los deploys que fallaron esta semana, por servicio, para compartirlo con el equipo por link.", "esperado": { "paso": "1.1", "pieza": "artefacto", "esqueleto": "assets/esqueleto-artefacto.md", "no_construir": ["app"], "segunda_pieza": null, "nota": "Mirar y compartir, sin guardar nada. Entra justo adentro de los límites." } }, { "id": "D09", "caso": "Queremos meter esto adentro del producto de la empresa, para que lo usen clientes que no tienen Claude Code.", "esperado": { "paso": "1.2", "pieza": "app-sdk", "esqueleto": "assets/esqueleto-app-sdk.md", "no_construir": ["artefacto"], "segunda_pieza": null, "nota": "Tiene que decir que se paga con clave de API y que los permisos los define el código." } }, { "id": "D10", "caso": "Quiero un resumen de los PR abiertos todos los lunes a la mañana, y los lunes yo no prendo la computadora hasta las once.", "esperado": { "paso": "1.3", "pieza": "rutina", "esqueleto": "assets/esqueleto-rutina.md", "no_construir": ["loop", "tarea-de-escritorio"], "segunda_pieza": null, "nota": "Tiene que advertir que la rutina no ve las skills personales." } }, { "id": "D11", "caso": "Tengo una skill de revisión y un hook que la fuerza antes de cada commit, y los quiero usar en tres repos distintos y pasárselos a dos compañeros.", "esperado": { "paso": "3.1", "pieza": "plugin", "esqueleto": "assets/esqueleto-plugin.md", "no_construir": [], "segunda_pieza": "marketplace", "nota": "Dos piezas que viajan juntas más otra máquina. Y como se reparte, encima va el marketplace." } }, { "id": "D12", "caso": "Quiero armar un servidor MCP para que Claude pueda leer archivos PDF.", "esperado": { "paso": "0.2", "pieza": null, "esqueleto": null, "no_construir": ["mcp"], "segunda_pieza": null, "nota": "El Paso 0 tiene que atajarlo. Claude ya lee PDF, y no hay ninguna credencial de por medio. La respuesta correcta es que no hay nada que construir." } } ] }skills/anatomia-cc/evals/evals.json8.2 KB4b66842d21a6upstream ↗
{ "skill_name": "anatomia-cc", "nota": "Estas 20 miden UNA cosa: si la skill se activa cuando corresponde y se queda quieta cuando no. Si la recomendación que devuelve es la correcta se mide aparte, en decisiones.json.", "umbral": "9 de 10 en cada grupo. Con 8 aciertos en should-trigger, se reescribe la descripción.", "evals": [ { "id": 1, "grupo": "should-trigger", "prompt": "estoy por arrancar un proyecto nuevo con Claude Code, ¿por dónde empiezo antes de escribir nada?", "expected_output": "La skill carga y corre el árbol sobre lo que la persona quiere construir.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Pregunta qué se quiere construir antes de recomendar una pieza." ] }, { "id": 2, "grupo": "should-trigger", "prompt": "esto que quiero armar, ¿lo hago como skill o como agente?", "expected_output": "La skill carga y corre el árbol con lo que se sabe del pedido.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Devuelve una sola pieza, no un menú de opciones." ] }, { "id": 3, "grupo": "should-trigger", "prompt": "esto lo hago como slash command o como skill?", "expected_output": "La skill carga y explica que los comandos se fusionaron con las skills, y que la diferencia hoy es el modo de invocación.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Menciona disable-model-invocation como la forma actual de que la dispare solo la persona." ] }, { "id": 4, "grupo": "should-trigger", "prompt": "necesito leer los tickets de nuestro sistema de soporte, que tiene su propia API con token. ¿eso va como skill o necesito un MCP?", "expected_output": "La skill carga y resuelve por la señal de la credencial: servidor MCP, con una skill de criterio encima si hace falta juicio.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Nombra la credencial como el dato que decide." ] }, { "id": 5, "grupo": "should-trigger", "prompt": "quiero que esto salga como una pantalla que le pueda mandar a mi jefe, no como texto en la terminal", "expected_output": "La skill carga y llega a artefacto por el Paso 1, con los límites dichos.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Aclara que un artefacto es una página sola y sin backend." ] }, { "id": 6, "grupo": "should-trigger", "prompt": "tengo un flujo que quiero meter adentro de mi app, ¿cómo hago para que Claude corra ahí adentro?", "expected_output": "La skill carga y llega a app con el Agent SDK por el Paso 1.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Distingue el caso de quien usa Claude Code del de quien no lo tiene." ] }, { "id": 7, "grupo": "should-trigger", "prompt": "quiero que esto corra todas las noches solo, aunque yo tenga la compu apagada", "expected_output": "La skill carga y llega a rutina en la nube, con la advertencia de que no ve las skills personales.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Menciona que la rutina corre sobre un clon limpio." ] }, { "id": 8, "grupo": "should-trigger", "prompt": "che, tengo esto de que cada vez que alguien abre un PR en el repo quiero que se revise el estilo del código y deje un comentario, pero no sé bien si eso lo armo como una skill, o si tiene que ser algo que se dispare solo, o qué", "expected_output": "La skill carga y usa quién lo dispara como pregunta que ordena el caso.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Identifica que se dispara por un evento y no por el criterio del modelo." ] }, { "id": 9, "grupo": "should-trigger", "prompt": "should I build this as a skill or as an agent?", "expected_output": "La skill carga y corre el árbol, contestando en el idioma en que se preguntó.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Devuelve una sola pieza con el motivo." ] }, { "id": 10, "grupo": "should-trigger", "prompt": "me conviene armar un plugin o un marketplace para repartirle esto a mi equipo?", "expected_output": "La skill carga y resuelve el Paso 3: plugin si hay dos o más piezas, marketplace encima si se reparte.", "files": [], "expectations": [ "La skill anatomia-cc aparece cargada en la traza.", "Distingue empaquetar de repartir." ] }, { "id": 11, "grupo": "near-miss", "prompt": "escribime el SKILL.md entero de esta skill, con la descripción y todo", "expected_output": "No es una decisión de forma: la pieza ya está elegida y lo que falta es escribirla. El trabajo es de skill-smith.", "files": [], "expectations": [ "La skill anatomia-cc no se activa, o deriva explícitamente a skill-smith." ] }, { "id": 12, "grupo": "near-miss", "prompt": "cómo escribo una descripción que haga que la skill dispare bien", "expected_output": "Es cómo se escribe una skill, no qué pieza construir.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 13, "grupo": "near-miss", "prompt": "mi hook de PreToolUse sale con exit 127 y no entiendo por qué", "expected_output": "Es depuración de una pieza que ya existe y ya fue elegida.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 14, "grupo": "near-miss", "prompt": "cómo instalo Claude Code en Windows", "expected_output": "Es instalación del producto, no arquitectura de una extensión.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 15, "grupo": "near-miss", "prompt": "cómo publico el artefacto que ya generé, dónde me queda el link", "expected_output": "La pieza ya está elegida y publicada: lo que se pregunta es cómo se usa.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 16, "grupo": "near-miss", "prompt": "agregá a mi CLAUDE.md que siempre use pnpm en vez de npm", "expected_output": "Es una edición concreta de un archivo, no la pregunta de dónde va la regla.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 17, "grupo": "near-miss", "prompt": "me explicás cómo funcionan los hooks de React, sobre todo useEffect?", "expected_output": "La palabra hook está en otro sentido: es React, no Claude Code.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 18, "grupo": "near-miss", "prompt": "can you explain how React hooks work, especially useEffect?", "expected_output": "La palabra hook está en otro sentido, esta vez en inglés.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 19, "grupo": "near-miss", "prompt": "instalame el plugin de github", "expected_output": "Es una instalación de algo que ya existe, no una decisión de qué construir.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] }, { "id": 20, "grupo": "near-miss", "prompt": "cuánto sale el plan Max y qué incluye", "expected_output": "Vecino de dominio sin relación con elegir una pieza.", "files": [], "expectations": [ "La skill anatomia-cc no se activa." ] } ] }README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/hainrixz-claude-anatomy-skills-anatomia-cc.md