Elegiste un subagente. Era una línea en un archivo de texto.

Abres Claude Code y te encuentras nueve palabras: skills, subagentes, comandos, plugins, servidores MCP, hooks, canales, rutinas y artefactos. Ninguna viene explicada, todas suenan a lo mismo, y la decisión de cuál te toca la tomas en el minuto uno, antes del primer archivo.

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. Nadie te avisa en el momento, porque las dos cosas funcionan: el día que las estrenas hacen exactamente lo que les pediste.

El costo no se ve el primer día. Se ve al mes, cuando la sesión arranca pesada, cuando el modelo empieza a elegir mal seguido entre piezas que se llaman parecido, y cuando abres una carpeta del proyecto y ya nadie se acuerda de por qué está ahí ni si se puede borrar.

Lo que se termina construyendo, y lo que el caso pedía

Cuatro casos que se repiten. En los cuatro la pieza elegida funciona; el problema es que había otra más chica que hacía lo mismo y se deshace en un minuto.

Las once veces que la pieza no era la del caso, cada una con lo que va en su lugar, están más abajo en esta misma página. Aquí importa solo el patrón: la pieza que suena importante casi nunca es la que el caso pedía.

Qué es Claude Anatomy, en una frase

Claude Anatomy es una skill que se instala en Claude Code, en la app de Claude o en las dos, y que no escribe código. Interroga tu caso y te devuelve una sola pieza: qué construir, el motivo en una frase y el esqueleto de archivos ya nombrado con tu caso adentro.

Las piezas que puede recomendarte son diez: una skill —y en cuál de sus cuatro modos—, un subagente, un hook, un servidor MCP, un plugin, una rutina, un artefacto, una app con el Agent SDK, una línea en el CLAUDE.md, o nada.

Y empieza donde casi ninguna guía empieza: preguntando si hace falta construir algo. Buena parte de los casos se cierran ahí mismo, y cuando eso pasa todavía te dice cuál de las salidas te toca: una regla que solo aplica a ciertos archivos, algo publicado que se instala en lugar de escribirse, un estilo de salida, o un script sin modelo adentro. Cuando la respuesta es que no construyas nada, lo dice en lugar de inventarte una pieza.

No enseña a escribir cada pieza. Enseña a elegir cuál.

El repositorio de la skill, si quieres leerla antes de instalarla: github.com/Hainrixz/claude-anatomy. Es markdown puro y licencia MIT.

El método son cuatro pasos y unas diez salidas posibles. No hace falta que te lo aprendas: la skill te lo va preguntando. Pero conviene leerlo una vez, porque el orden no es decorativo — cada paso descarta una familia entera de respuestas antes de dejarte pasar al siguiente.

Y hay un atajo. Tres preguntas se llevan la mayoría de los casos sin que tengas que recorrer nada.

El árbol completo, paso por paso

Se lee de arriba abajo, y dentro de cada paso la primera pregunta que da que sí lo cierra: las de abajo ya no se leen. Por eso el orden pesa tanto como las preguntas.

El Paso 0 es el que casi nadie corre por su cuenta, porque cuando llegas hasta aquí ya decidiste que quieres construir algo. Este prompt le pide a la skill que lo recorra completo antes de recomendarte nada, y que sea dura contigo.

Antes de recomendarme ninguna pieza, córreme el Paso 0 completo sobre este caso y sé duro conmigo.

Quiero que revises, en este orden, si lo que necesito se resuelve sin construir nada:

1. ¿Es solo que Claude se acuerde de una regla mía? Si sí, dime la línea exacta que va en el CLAUDE.md, y si la regla aplica solo a ciertos archivos dime cómo dejarla como regla por ruta.
2. ¿Ya existe algo publicado que haga esto? Si sí, dime qué instalar en vez de construirlo.
3. ¿Lo que me molesta es CÓMO me contesta y no lo que sabe? Si sí, eso es un estilo de salida, no una skill.
4. ¿Lo resuelve un script sin modelo adentro? Si siempre se hace igual y no hay nada que decidir, dime que es un script y escríbelo.

Solo si las cuatro dan que no, sigue al resto del árbol.

MI CASO:
[Descríbelo aquí en dos o tres frases.]

Con esto ya puedes correr el árbol a mano sobre tu propio caso. Lo que sigue es instalar la skill que te hace las preguntas, y en Claude Code son dos comandos.

Esta es la ruta principal y la más corta. Dos líneas dentro de Claude Code y la skill queda puesta: no hay instalador que bajar, ni archivo de configuración que editar, ni una llave que pegar en ningún lado.

Se escriben dentro de Claude Code, no en la terminal del sistema, y van en este orden. El segundo no encuentra nada si no corriste el primero.

Los dos comandos, en este orden

El nombre repetido del segundo no es un error de dedo. A la izquierda del arroba va el plugin y a la derecha el catálogo del que sale, y en este caso los dos se llaman igual.

Si prefieres no agregar un catálogo

La misma skill viaja como un .zip de 40 KB en el release. Descargas el archivo, lo dejas en la carpeta de tu proyecto y corres estas dos líneas, esta vez sí en la terminal del sistema.

El archivo se llama anatomia-cc-v0.3.0.zip y está en el último release en GitHub.

El .zip trae la carpeta anatomia-cc en la raíz, así que al descomprimir queda en el lugar exacto y no hay nada que mover después. Esa misma forma es la que después exige el panel de la app, y por eso el mismo archivo sirve en los dos lados.

Proyecto o usuario

Es la única decisión real de esta sección, y la pregunta que te va a hacer la vista de detalle. Las dos rutas funcionan igual de bien: lo que cambia es a cuántos lugares alcanza y qué tan fácil es dar marcha atrás.

Por eso el default recomendado es proyecto: es la ruta que se deshace sin pensarla. Moverla después no cuesta nada.

Con qué nombre te queda

Este es el detalle que casi nadie publica y que se confirmó instalándola de verdad: el nombre con el que la puedes llamar cambia según la vía que usaste.

suelta en .claude/skills/anatomia-cc/   →   /anatomia-cc
instalada como plugin                  →   /claude-anatomy:anatomia-cc

En los dos casos se dispara sola por su descripción: escribes tu duda en español y se activa sin que menciones nada. El nombre solo importa si la quieres llamar tú a mano, o si la buscaste y creíste que no había quedado instalada.

Y sí, la skill se llama anatomia-cc mientras que el repositorio y el plugin se llaman claude-anatomy. No es un descuido: hay una regla que prohíbe la palabra «claude» dentro del nombre de una skill, y está contada en la sección siguiente porque es ahí donde te muerde.

Si prefieres no escribir comandos

También puedes pedírselo en español y que Claude Code haga el trabajo: clona el repositorio, copia la carpeta completa donde va, borra lo temporal y te confirma que el nombre coincide.

Instálame esta skill en este proyecto: https://github.com/Hainrixz/claude-anatomy

Hazlo así:

1. Clona el repositorio en una carpeta temporal, fuera de mi proyecto.
2. Copia la carpeta skills/anatomia-cc completa —con sus subcarpetas references/ y assets/, no solo el SKILL.md suelto— dentro de .claude/skills/ de este proyecto, de modo que quede en .claude/skills/anatomia-cc/. Ojo con el nombre: la carpeta de la skill es anatomia-cc aunque el repositorio se llame claude-anatomy.
3. Borra la carpeta temporal cuando termines.
4. Confírmame que la carpeta quedó con el mismo nombre que el campo name del frontmatter. En Claude Code el nombre con el que la invoco sale de la carpeta, así que si no coinciden voy a buscarla mal; y si algún día subo el .zip a la app, ahí sí es obligatorio que sean iguales.
5. Dime con qué nombre me va a quedar disponible y qué tengo que hacer para que aparezca en esta sesión.

Antes de terminar, dime en una línea qué cambiaría si la hubiera instalado para todos mis proyectos en vez de solo en este, y cuál de las dos rutas es más fácil de deshacer.

Cómo sacarla, que es la mitad que casi nunca se escribe

Esta página entera se apoya en que la pieza más chica es la más fácil de tirar cuando te equivocaste. Sería raro no decirte cómo se tira esta. Son tres comandos y ninguno pide confirmación de más, así que conviene leerlos antes de correrlos.

Si la instalaste como carpeta suelta en lugar de como plugin, no hay comando que correr: borras la carpeta anatomia-cc de donde la hayas dejado y desaparece. En el proyecto está dentro de .claude/skills/; si elegiste dejarla disponible en todos, está en la carpeta de skills de tu configuración de usuario. Por eso la ruta de proyecto es el default recomendado: es la que se deshace sin acordarte de nada.

O que lo haga él y te diga qué quedó

Lo incómodo de desinstalar a mano es que nunca sabes si quedó algo suelto en la otra ruta. Este prompt revisa las dos, quita lo que encuentra y te reporta qué tocó y qué no.

Quiero desinstalar por completo la skill de Claude Anatomy y dejar todo como estaba antes.

Hazlo en este orden y dime qué encuentras en cada paso:

1. Revisa si está instalada como plugin y, si lo está, desinstálala.
2. Revisa si quedó registrado su catálogo de plugins. Si ya no lo usa ningún otro plugin, quítalo también; y si sí lo usa alguno, avísame antes de tocarlo.
3. Busca si además quedó una copia suelta como carpeta, tanto en la carpeta de skills de este proyecto como en la de mi usuario. Si encuentras alguna, dime dónde está y bórrala solo si te confirmo.
4. Al final dime tres cosas: qué quitaste, qué dejaste, y si hace falta que reinicie o recargue algo para que deje de aparecer en esta sesión.

Si en algún paso no encuentras nada, dilo en lugar de asumir que ya estaba limpio.

Con esto ya la tienes en Claude Code. Las dos secciones que siguen son las otras dos superficies, y ninguna de las dos hereda lo que acabas de hacer aquí.

En la app de Claude no se escriben comandos. Se sube un archivo una sola vez y la skill queda disponible en el chat de las tres pantallas: navegador, escritorio y celular. Es el mismo .zip del release que usarías en la terminal, sin editarle nada.

El trámite completo toma un minuto y son cuatro toques. Lo que hace perder tiempo no es ninguno de los cuatro: es un interruptor apagado que esconde el panel donde van.

Primero el interruptor, después el archivo

Configuración  →  Capacidades
     └─ Ejecución de código y creación de archivos   ·   prendido

Los cuatro pasos

Con el interruptor prendido el panel ya está en su lugar, y lo que queda es bajar un archivo y elegirlo.

En qué planes funciona

Las skills están en los cinco planes de la app. Lo que cambia entre uno y otro no es la función: es quién tiene que dar permiso antes de que puedas subir algo.

Si estás en Team o en Enterprise y el panel no te deja subir nada aunque tengas la ejecución de código prendida, revisa ese permiso antes de dar por rota la skill.

Por qué el mismo archivo sirve sin editarle nada

Que una skill funcione en la app y en la terminal no es automático. Las skills siguen un estándar abierto, Agent Skills, que admite seis campos de configuración arriba del archivo. Claude Code acepta bastantes más, y ahí está la trampa.

Un campo de más no se ignora en silencio: la subida falla con un error duro y el archivo se queda afuera. Esta skill usa cuatro campos y los cuatro están en el estándar, así que por ese lado entra sin tocarle nada.

Guárdate el dato para cuando subas otras skills. Si una tuya funciona bien en Claude Code y el panel de la app la rechaza, esa lista de campos es lo primero que hay que mirar. Lo segundo está aquí abajo, y es más tramposo.

Skill name in SKILL.md cannot contain the reserved word 'claude'.

Por eso la skill se llama anatomia-cc mientras el repositorio, el plugin y esta misma guía siguen llamándose claude-anatomy. La restricción es solo del campo name y del nombre de su carpeta: la marca, la dirección del repo y el comando del plugin no la tocan.

Si vas a escribir una skill que algún día quieras subir a la app, elige el nombre pensando en esto desde el primer día. Cambiarlo después obliga a renombrar la carpeta, rehacer el .zip y publicar una versión nueva, y a corregir cada lugar donde estaba escrito el nombre viejo.

Qué cambia respecto a Claude Code

En la terminal la skill te da la recomendación y el esqueleto de archivos, y sigues de largo construyendo ahí mismo. En la app te da exactamente lo mismo, pero como texto: te sirve para decidir y para entender, y después vas a Claude Code a construirlo.

Aun así vale la pena tenerla en los dos lados, porque la duda casi nunca aparece frente a la terminal. Aparece antes: pensando el problema desde el celular, o explicándoselo a alguien que te pregunta si eso es una skill o un subagente.

Cómo saber que quedó activa, si aquí no hay comandos

Aquí no existe un prompt para instalarla, y conviene decirlo en lugar de inventar uno: en la terminal le pides a Claude Code que clone y copie archivos porque tiene manos para hacerlo, y en la app no las tiene. La subida es un archivo que eliges tú en una pantalla, y no hay forma de pedírsela por escrito.

Lo que sí se resuelve con un prompt es lo de después. Como en la app tampoco hay comandos con diagonal, no puedes escribir su nombre para ver si está: la única señal fiable es darle un caso y mirar la forma de la respuesta.

Tengo un caso y quiero que me digas qué construir para resolverlo.

Necesito revisar cuarenta archivos de mi repositorio buscando problemas de seguridad, y que solo me traigas los hallazgos, sin el ruido de los archivos que están bien.

Contéstame con este formato exacto:

1. La pieza recomendada, UNA sola, con el motivo en una frase y el número de la pregunta del árbol que la decidió.
2. Si es una skill, en cuál de sus cuatro modos va.
3. El árbol de archivos de esa pieza, ya nombrado con mi caso.
4. Qué de esto NO hace falta construir.

Si contesta con una pieza, el número de la pregunta que la decidió y un árbol de archivos, la skill cargó. Si contesta con una explicación general sobre las opciones que existen, no cargó — y lo más probable es que el interruptor esté apagado.

Con el archivo arriba y su interruptor prendido, la skill ya está en el chat de las tres pantallas. Lo que sigue es la parte que casi nadie revisa, y donde está la trampa que hace perder una tarde.

Esta es la más corta de las tres secciones de instalación, y por una razón sencilla: aquí no hay nada que instalar. Cowork usa las skills habilitadas en tu cuenta de claude.ai, así que si subiste el .zip en el paso anterior, ya la tienes en los dos lados.

Es el mismo interruptor de siempre: lo que enciendes en el panel de tu cuenta es lo que ve Cowork. Por eso la sección es corta. Lo que viene después no es cómo instalarla, es la advertencia.

Ahí no existen los comandos con diagonal

Ni en el chat ni en Cowork hay comandos con diagonal para skills. La skill se aplica sola cuando la tarea encaja con su descripción, y no tienes forma de llamarla por su nombre.

Eso cambia cómo la usas, no si funciona. En lugar de invocarla, describes tu caso —qué ibas a construir y para qué— y ella entra cuando reconoce el problema. En Claude Code también se dispara sola casi siempre; la diferencia es que allá, además, la puedes forzar.

También cambia cómo compruebas que está puesta, y por el mismo motivo: sin comandos con diagonal no puedes escribir su nombre para ver si responde. El prompt de comprobación de la sección anterior sirve igual aquí, porque no depende de llamarla por su nombre sino de mirar la forma de lo que contesta. Y para quitarla es el mismo panel de la cuenta: lo que apagues o borres allá desaparece de Cowork sin que tengas que entrar aquí a nada.

Las tres superficies, una al lado de la otra

El resumen de las secciones 03, 04 y 05 en una sola vista. Si te llevas una sola cosa, que sea la última columna: fuera de Claude Code lo que recibes es la decisión escrita, no el archivo.

Que fuera de Claude Code no construya nada no la deja sin uso. La duda de qué pieza te toca suele aparecer antes de abrir la terminal, y esa es justo la que resuelve.

Con esto la tienes en las tres superficies. Lo que sigue es qué la despierta y qué te contesta cuando lo hace.

Esta es la parte donde otras herramientas te piden memorizar algo. Aquí no. La skill se activa sola por su descripción: escribes la pregunta que ibas a escribir igual, con las palabras que ya usabas, y ella entra a la conversación cuando reconoce el tema.

Eso cambia el momento en que la usas, que es lo que de verdad importa. No es algo que abres cuando te acuerdas de que lo instalaste: aparece justo cuando dudas, que es el minuto exacto en que la decisión se toma mal.

Las frases que la despiertan

Todas estas son cosas que alguien escribe de todos modos cuando está trabado. Ninguna es un comando y ninguna hay que copiarla textual.

• «esto lo hago como skill o como agente»
• «necesito un MCP o alcanza con una skill»
• «esto va como comando o como skill»
• «quiero que esto salga como una pantalla que le pueda mandar a alguien»
• «quiero meter esto adentro de mi app»
• «quiero que corra solo todas las noches»
• «por dónde empiezo»

También dispara en inglés. Una frase como «should I build this as a skill or an agent» la despierta igual, sin que tengas que cambiar de idioma a propósito.

El disparo más común es literalmente ese: la duda tal cual, con dos líneas de contexto debajo para que no tenga que adivinar de qué hablas.

Esto lo hago como skill o como agente?

Lo que quiero es que cada vez que abra un proyecto de un cliente, Claude ya sepa cómo cobramos, qué plantilla de propuesta usamos y con qué tono le escribimos a esa persona en particular.

Si prefieres saltarte el ida y vuelta, contesta de entrada las tres preguntas que más rinden: quién aprieta el botón, si toca algo de afuera que pida su propia credencial, y qué queda cuando termina y quién lo mira. La tercera es la que casi todos olvidan, y es la que decide si esto vive adentro de una sesión o fuera de ella.

Quiero decidir qué construir en Claude Code para este caso. Te contesto de entrada lo que sé, y si te falta algo pregúntame antes de recomendar.

QUÉ QUIERO QUE PASE
[Describe aquí, en dos o tres frases y sin usar ninguna palabra técnica, qué quieres que ocurra. Habla del resultado, no de la herramienta.]

QUIÉN APRIETA EL BOTÓN
[Elige uno: yo, escribiendo algo / el modelo, cuando el tema aparece solo / un evento de Claude Code, como guardar un archivo / el reloj, a una hora fija / un sistema de afuera / nadie, es una regla que Claude debe saber siempre.]

¿TOCA ALGO DE AFUERA QUE PIDA SU PROPIA CREDENCIAL?
[Una base de datos, una API, la cuenta de un servicio. Si no toca nada de afuera, dilo.]

CUANDO TERMINA, ¿QUÉ QUEDA Y QUIÉN LO MIRA?
[Elige uno: texto en mi terminal / una pantalla que alguien abre en el navegador / archivos cambiados en el repo / una respuesta que consume otro programa.]

Dame UNA sola pieza recomendada, el motivo en una frase, y el árbol de archivos ya nombrado con mi caso. Si el caso se reparte en dos piezas, dime cuál se construye primero y por qué.

Qué te devuelve

La respuesta tiene una forma fija. No es un ensayo sobre las opciones ni una tabla comparativa para que elijas tú: son cuatro cosas, siempre en este orden.

Un ejemplo, de la pregunta a la carpeta

Pides revisar cuarenta archivos buscando problemas de seguridad y que te traiga solo los hallazgos. La respuesta que casi todos esperan es un subagente. La que sale del árbol es una skill que corre en un subagente, y la diferencia entre las dos es una línea de configuración en lugar de un archivo aparte que después hay que mantener.

tú    › 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/

Fíjate en el número de la pregunta. Está ahí para que puedas ir al árbol, ver por dónde pasó tu caso y discutir el paso exacto si no estás de acuerdo, en lugar de aceptar la recomendación porque sí.

Y así se ve cuando no le das todo de entrada

El ejemplo de arriba es el caso corto, porque la pregunta ya venía con lo que hacía falta para contestarla. La mayoría de las veces no es así: escribes lo que quieres que pase y todavía faltan las tres cosas que deciden. Ahí es donde la skill interroga en lugar de adivinar.

Este es el recorrido completo de un caso que llega crudo. Fíjate que no pregunta por gusto: cada una de las tres respuestas mueve el resultado a otro lado del árbol.

tú    › quiero que cuando entre un ticket de soporte,
        Claude lo lea y me avise si es urgente

skill › Antes de recomendarte nada, tres preguntas.
        ¿Quién aprieta el botón? ¿Tú, cuando te
        acuerdas de revisar, o tiene que pasar solo?

tú    › solo, cuando entra el ticket

skill › ¿De dónde salen los tickets? ¿Hay que entrar
        a algún sistema con su propia credencial?

tú    › sí, están en Zendesk

skill › Cuando termina, ¿qué queda y quién lo mira?

tú    › un mensaje en Slack para mí

skill › Paso 2, pregunta 2.2 → son DOS piezas, y el
        orden no es opcional.

        1. Servidor MCP, primero. Guarda la
           credencial de Zendesk de su lado y expone
           las operaciones que pediste: leer los
           tickets nuevos y mandar el aviso.

        2. Skill, encima. El criterio de qué es
           urgente, que es lo que sabes tú y la
           API no.

        Al revés no funciona: la skill sola no entra
        a Zendesk por más que se lo escribas.

        tickets-urgentes/
          SKILL.md
          references/criterio-de-urgencia.md

Son tres preguntas, no doce, y son siempre las mismas: quién dispara, si hay una credencial de por medio, y qué queda al final. Si contestas las tres de entrada —que es lo que hace el segundo prompt de arriba— se salta el ida y vuelta y va directo al veredicto.

El detalle que más cambia el resultado es el segundo. Sin Zendesk de por medio, ese mismo caso habría terminado en una sola pieza. La credencial es lo que lo parte en dos, y por eso vale la pena contestar esa pregunta con cuidado.

Cuando el caso se parte en dos

El error más caro de esta guía no es elegir la pieza equivocada: es meter dos trabajos distintos adentro de una sola. Entrar a un sistema de afuera que pide su propia credencial es un trabajo; aplicar criterio sobre lo que ese sistema trae es otro. Cuando tu caso tiene los dos, son dos piezas, y cuál va primero no es opcional.

Creo que este caso no es una sola pieza. Quiero que me lo separes.

Si de verdad son dos, dime:

1. Cuál es la pieza de abajo, la que toca el sistema de afuera y guarda la credencial.
2. Cuál es la pieza de arriba, la que aplica el criterio sobre lo que trae la de abajo.
3. Cuál construyo primero y por qué la otra no sirve sin ella.
4. Qué operaciones concretas expone la de abajo. No quiero que envuelvas la API entera por si acaso: solo lo que pedí.

Y si me equivoqué y en realidad es una sola pieza, dímelo sin rodeos.

MI CASO:
[Descríbelo aquí, incluyendo a qué sistema de afuera hay que entrar y qué decisión hay que tomar con lo que traiga.]

Eso es todo lo que hay que saber para usarla. Lo que sigue es cómo confirmar que de verdad quedó puesta en la superficie donde la instalaste, en lugar de darlo por hecho y descubrirlo el día que la necesitas.

Cuando una skill no queda bien puesta no hay error, no hay aviso en rojo y no hay nada que se vea distinto. Le preguntas algo a Claude, te contesta bien, y la skill nunca entra. Por eso conviene gastar treinta segundos en confirmarlo ahora, en la superficie donde vas a trabajar, y no descubrirlo a mitad de un caso real.

Cada superficie se revisa distinto. Estas son las tres, y después la prueba que funciona en cualquiera de ellas.

/anatomia-cc                  suelta en .claude/skills/
/claude-anatomy:anatomia-cc   instalada como plugin

En los dos casos la skill también se dispara sola por su descripción. Escribir el nombre es la forma de comprobar que está, no la forma de usarla.

La prueba que sirve en las tres

Pídele a Claude que te resuma qué haría con un caso de prueba concreto, algo tuyo y de una línea: que quieres que cierto trabajo corra solo todas las noches, por ejemplo. No hace falta leer la respuesta entera. La forma ya te dice si la skill cargó.

Queda un chequeo más, que no es de instalación sino de precio: dentro de Claude Code hay un comando que te muestra en qué se está yendo la ventana de contexto ahora mismo, desglosado por pieza. Es donde se mide lo que la sección 10 explica, y ahí está el comando con lo que hay que mirar.

Si aparece en la lista, el interruptor está prendido y la respuesta de prueba trae pieza y esqueleto, ya quedó. De aquí en adelante esta guía deja de hablar de instalación y pasa a lo que la skill decide por ti.

Durante mucho tiempo esto eran tres piezas distintas: la skill que el modelo usaba solo, el comando de barra que escribías tú, y el subagente que corría aparte para no llenarte el contexto. Hoy es una sola 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.

.claude/commands/deploy.md          →  /deploy
.claude/skills/deploy/SKILL.md      →  /deploy
.claude/skills/deploy/references/   →  archivos de apoyo, solo por este lado

Lo que no cambió, y conviene no confundir

El subagente sigue siendo una pieza aparte, con su archivo y su carpeta. Eso no se fusionó con nada.

Lo que cambió es que una skill ahora puede correr adentro de un subagente con context: fork, sin que tengas que escribirle uno propio. Escribir el subagente aparte se justifica cuando además es reusable: cuando varias skills o varias tareas distintas lo van a llamar. Para una sola, es una carpeta de más.

Esta página asume que ya sabes qué es cada pieza. Si alguna suena vacía, el glosario está en Anatomía de Claude, que las explica desde cero.

Las dos preguntas que fijan el modo

No son cuatro opciones sueltas de un menú. Son dos preguntas independientes, y el modo sale de cruzarlas.

La fila dice dónde corre y la columna quién la dispara. Cualquier casilla es válida, y la de arriba a la derecha —el default— es la que quieres la mayoría de las veces.

Los cuatro casos, dichos simple

Dicho como se lo explicarías a alguien en voz alta:

• El default. No escribes nada en el frontmatter: la puedes invocar tú y el modelo también la levanta cuando el tema aparece.
• disable-model-invocation: true — solo tú. Es lo que antes era un comando, y va para cosas con consecuencias: desplegar, commitear, mandar un mensaje. No quieres que el modelo decida por su cuenta que hoy es buen día para desplegar. Regalo extra: no ocupa contexto hasta que la invocas.
• user-invocable: false — solo el modelo. Va para conocimiento de fondo. Cómo funciona el sistema viejo de facturación es algo que Claude debería saber cuando el tema sale, pero nadie quiere escribir /sistema-viejo.
• context: fork — corre en un subagente. Solo sirve si la skill trae una tarea que ejecutar. Si es conocimiento y nada más, el subagente recibe las pautas, no tiene nada que hacer con ellas y vuelve con las manos vacías.

El precio de usar los campos extra

Todo lo de arriba tiene letra chica, y conviene saberla antes y no después. Los tres campos de esta sección —context, disable-model-invocation y user-invocable— son extensiones de Claude Code: no están en el estándar abierto que siguen las skills. Mientras la skill viva en la terminal, no pasa nada. El día que intentes subirla a la app, cualquiera de ellos hace fallar la subida con un error duro: no lo ignora, rechaza el archivo.

Ya sabemos que esto va a ser una skill. Lo que me falta es el modo.

Decídelo con las dos preguntas que lo fijan —quién la dispara y dónde corre— y dime cuál de los cuatro modos me toca, con el frontmatter exacto que va en el SKILL.md.

Contéstame también estas tres, que son las que me hacen dudar:

- ¿Debería quedar fuera del menú de barra, o quiero poder invocarla yo?
- ¿Tiene sentido que corra aparte, en su propia ventana, o eso me va a devolver las manos vacías?
- ¿Esta skill va a viajar fuera de Claude Code —a la app, a otra máquina, a otro agente—? Si sí, dime qué campos del frontmatter tengo que sacrificar y por qué.

LO QUE HACE LA SKILL:
[Descríbelo aquí. Di si trae una tarea que ejecutar o si es conocimiento de fondo — eso cambia la respuesta.]

El modo no se decide al final: cambia el archivo desde la primera línea. Si la pieza ya está elegida y lo único que falta es esto, el prompt de arriba lo resuelve en un turno.

Casi todos salen del mismo lugar: elegir la pieza por lo que suena importante en vez de por quién la dispara y qué carga. Un subagente suena más serio que una línea en un archivo de texto. Un plugin suena más terminado que una carpeta suelta. Un servidor con cuarenta herramientas suena a que dejaste todo cubierto.

Ninguno de los once falla de forma ruidosa. No hay un error en rojo: hay una pieza que mantienes sin motivo, un contexto que pagas en todas las sesiones, o una regla que se cumple casi siempre. Por eso conviene reconocerlos por la forma y no por el síntoma.

La tabla va completa a propósito, para que puedas recorrerla contra lo que ya tienes construido. Tres de los once se desarrollan más abajo, porque son los que salen más caros y los que más se repiten.

Si alguna palabra de la tabla te suena a idioma ajeno, el glosario de las piezas está en Anatomía de Claude: qué es cada una, explicada desde cero. Esta página asume que ya las conoces por nombre.

Ninguna fila dice que lo que ya construiste esté roto. Dicen que hay una pieza más chica que hace lo mismo y que cuesta menos mantener.

Los tres que salen más caros

Pásale la tabla a lo que ya tienes en disco

La tabla se lee en cinco minutos y no cambia nada por sí sola. Lo que sirve es correrla contra el proyecto que ya tiene meses encima. Este prompt le pide a la skill que abra la carpeta de configuración y el CLAUDE.md, pase cada pieza que encuentre por el árbol y te diga cuáles habrían salido distintas hoy.

Revisa lo que ya tengo construido en este proyecto y dime qué está en la forma equivocada.

Mira la carpeta .claude/ de este repo y también mi CLAUDE.md. Para cada pieza que encuentres —skills, subagentes, comandos, hooks, servidores MCP, plugins— dime:

1. Qué es y qué hace, en una frase.
2. Qué pieza habría salido si el caso pasara hoy por el árbol de decisión.
3. Si no coinciden, cuál es el anti-patrón exacto y qué habría que hacer en su lugar.
4. Qué me está costando en contexto: qué entra en el turno cero de cada sesión y qué entra solo cuando se dispara.

Pon primero lo que más me está cobrando sin que lo use. Y si hay algo que se puede borrar sin reemplazo, dímelo — que sobre una pieza es más común que faltar una.

Pide el resultado ordenado por lo que más te cobra sin que lo uses. Que sobre una pieza es más común que falte una, y borrar sin reemplazo es una respuesta válida.

Ninguno de los once se arregla leyendo más. Se arreglan abriendo la carpeta y preguntando, pieza por pieza, quién la dispara y qué carga.

Cuando dudas entre una skill y un subagente, o entre una regla en el CLAUDE.md y un hook, la pregunta que casi siempre te haces es cuál puede hacer el trabajo. Y la respuesta suele ser que las dos pueden. Por eso la comparación no se resuelve por capacidad: se resuelve por precio.

El precio de una pieza son dos cosas: cuánto te cobra antes de que escribas la primera palabra, y cuánto te cobra después. Una sesión que arranca con medio contexto ocupado no se rompe, se pone tonta más temprano. Y eso no se nota el día que la instalas: se nota al mes, cuando ya nadie se acuerda de por qué esa carpeta está ahí.

Qué te cobra cada pieza, y en qué momento

El turno cero es todo lo que ya está adentro antes de tu primer mensaje. La columna de la derecha es lo que llega después, y solo si hace falta.

La cuarta fila es la skill que lleva el campo disable-model-invocation en su frontmatter: se queda fuera de la lista de descripciones y no existe para el modelo hasta que la llamas. Es la forma más barata que hay de tener una skill instalada.

Si alguna de esas palabras te suena de lejos, el glosario está aparte: Anatomía de Claude, pieza por pieza. Aquí se asume que ya sabes qué es cada una.

Las tres cosas que casi nadie sabe

El número real de esta skill

Todo lo de arriba vale para cualquier pieza. Esto vale para esta: es lo que cuesta tener Claude Anatomy instalada, medido en la máquina y no calculado a ojo.

Esos dos números son exactamente la fila de la skill en la tabla de arriba, vista desde un caso concreto. Los cuatrocientos tokens son el precio de tenerla disponible por si acaso: se pagan en cada sesión, incluso en las que no hay ninguna decisión que tomar. Los cinco mil solo los pagas el día que de verdad tienes la duda, y si ese día no llega, no los pagas nunca.

Esa es la cuenta que te toca hacer con cualquier pieza que estés pensando instalar, no solo con esta. Cuánto cuesta que esté ahí, cuánto cuesta usarla, y con qué frecuencia la vas a usar de verdad. Si el uso es raro y el costo fijo es alto, sobra. Si el costo fijo es una línea y el uso es semanal, se queda.

Los números cambian entre versiones y entre máquinas, así que el que salga en tu pantalla manda sobre el que está escrito aquí.

La regla de la sección es esa: esto se mide, no se estima. Lo que no cambia con las versiones es el orden de las preguntas — quién dispara la pieza, qué carga y en qué momento.

Toda herramienta que sirve tiene un borde. El de esta se ve rápido: no construye nada. Corre el árbol sobre tu caso, te dice qué pieza te toca y por qué, y te deja el esqueleto de archivos con los nombres puestos. Ahí se detiene, a propósito.

Conviene saber dónde se detiene antes de instalarla y no después. Estas son las tres cosas que no hace, lo que trae adentro de la carpeta, y qué está verificado de verdad frente a qué solo está escrito.

Las tres cosas que no hace

Qué trae adentro

La carpeta es markdown puro: no hay nada que compilar ni que ejecutar. El SKILL.md carga siempre que la skill se dispara; las referencias solo se leen si el caso las pide, y los assets se copian tal cual cuando toca entregarte el esqueleto.

skills/anatomia-cc/
├── SKILL.md                          el árbol y el contrato de salida
├── references/                       se leen solo si hacen falta
│   ├── como-se-carga-el-contexto.md  qué entra en el turno cero, y qué no
│   ├── modos-de-skill.md             los cuatro modos y el frontmatter entero
│   ├── mcp-o-skill.md                la señal de la credencial
│   ├── afuera-de-la-sesion.md        artefacto, app con el SDK, rutina
│   └── anti-patrones.md              los once, con antes y después
├── assets/                           se copian, no se leen
│   ├── arbol-de-decision.md          el árbol entero en una página
│   └── esqueleto-*.md                ocho esqueletos, uno por pieza
└── evals/
    ├── evals.json                    20 pruebas de disparo
    └── decisiones.json               12 pruebas de decisión

Los ocho esqueletos son uno por pieza: skill, subagente, hook, servidor MCP, plugin, rutina, artefacto y app con el Agent SDK. Es lo que te llega pegado cuando el árbol cierra en una de ellas.

Proyecto de la comunidad, no afiliado a Anthropic. Si algo de lo que leíste aquí ya no coincide con lo que ves en pantalla, gana la documentación de hoy.