Si usas Claude conoces las Skills: carpetas con un archivo de instrucciones que la IA carga cuando hacen falta. Se parecen a un Reminder lo bastante como para pensar «eso ya lo tengo». No hacen el mismo oficio, y la diferencia se ve en una línea: una Skill responde a cómo se hace algo, un Reminder responde a quién es quien lo hace.
La objeción, dicha antes de que la pienses tú
Cierto en toda la línea, y no vamos a darle vueltas. Una Skill es una carpeta con un SKILL.md dentro: dos líneas de encabezado — un nombre y una descripción — y luego texto. Es markdown, es tuyo, está en git, y si mañana cambias de idea te lo llevas. Nadie te ha encerrado en nada.
El mecanismo también está bien pensado. Mientras la Skill no haga falta, de ella solo queda en memoria la descripción — un centenar de palabras; el cuerpo se carga cuando la IA decide que es pertinente, y los archivos de apoyo solo si los abre de verdad. Se llama divulgación progresiva, y es la manera correcta de dar a una IA cien competencias sin pagarlas todas en cada frase.
Así que no: esta página no existe para decirte que las Skills están mal hechas. Existe porque ese mecanismo, que para una capacidad es una virtud, para una identidad es el defecto.
Una Skill entra cuando hace falta. Es toda su elegancia: no ocupa sitio hasta que hay un motivo, y el motivo lo reconoce la IA leyendo la descripción. Perfecto para «maquetar una presentación según nuestras reglas», que hace falta el martes y no el jueves.
Una identidad no funciona así. Quién eres no es una competencia que se activa cuando el tema lo pide: es lo que ya está ahí antes de que abras la boca, y decide cómo lees la pregunta. Algo que aparece solo cuando se le invoca no es un carácter, es un manual.
Es la misma diferencia que hay entre saber cocinar y tener hambre. Lo primero se saca cuando toca; lo segundo te mueve incluso cuando no estás pensando en comida.
En un SKILL.md no hay manera de escribir esta parte no la puedes reescribir tú. No es un olvido: una Skill es algo que le das a la IA para que lo use, y no hay nada que defender.
En un Reminder, en cambio, al otro lado hay alguien que lee, entiende y podría reescribir — y entonces cada bloque declara cuánto es tuyo: desde las reglas que solo tú puedes cambiar hasta los apuntes que la IA actualiza sin preguntar. Es la diferencia entre un manual y una constitución, y es también el motivo por el que el Reminder tiene una estructura en vez de ser prosa.
| Una skill | Un Reminder | |
|---|---|---|
| A qué responde | cómo se hace una cosa | quién es quien la hace |
| Cuándo entra en contexto | cuando la IA la juzga pertinente | siempre, desde la primera línea |
| Qué contiene | un procedimiento, ejemplos, scripts | núcleos, módulos, memorias, permisos |
| Quién puede reescribirla | tú, fuera de la conversación | depende de la zona: está declarado dentro del archivo |
| Si la quitas | la IA deja de saber hacer esa cosa | la IA deja de ser alguien |
| Qué recuerda | nada: mañana es igual que hoy | cómo fue: en la memoria asociada del módulo |
No es o lo uno o lo otro, y no conviene convertirlo en eso. La división que funciona es nítida: las Skills para las capacidades, el Reminder para la identidad. Misma conversación, ningún conflicto — porque no se disputan el mismo sitio.
Con los agentes de código la misma división ya tiene su sitio: el archivo que el agente lee al arrancar — CLAUDE.md, AGENTS.md — es donde va la identidad, y las Skills siguen siendo los procedimientos que esa identidad sabe ejecutar.
Y la frontera es más porosa de lo que parece. Una Skill que ya tienes se traduce a un módulo, casi línea a línea: no hay nada que reinventar, porque las dos formas responden a las mismas cuatro preguntas.
Vale también al revés, y es la parte que sorprende. De obligatorio, en un SKILL.md, hay dos líneas de encabezado — un nombre y una descripción. Debajo eres libre: la estructura del cuerpo no la prescribe nadie. Que las Skills se escriban en prosa suelta es una costumbre extendida, no una regla — y las propias guías de Anthropic recomiendan pasos numerados, plantillas de salida y ejemplos, es decir exactamente la forma que un módulo ya tiene. Debajo del encabezado cabe sin reescrituras.
Una sola cosa no cruza, y conviene decirla. Dentro de un módulo la línea que declara esta parte no la reescribes tú tiene su sitio, y la app la hace respetar; dentro de un SKILL.md esa línea no tiene dónde estar, y ninguna app está en el circuito para defenderla — los marcadores de zona se quedan ahí como texto, y nadie los aplica. Traducir una capacidad funciona perfectamente. Traducir la identidad no: y eso es todo lo que esta página está diciendo.
Traducir una skill en un módulo es un camino. El otro es no traducirla en absoluto. El cuerpo de un SKILL.md es markdown, y un módulo lo aloja tal cual, bajo una línea que declara de quién es esa pieza: en el Estándar se llama ### SUB-MODULE:, y debajo va el texto entero de la skill — su función, sus pasos, sus ejemplos. No se reescribe nada. Se dice de quién es, y dónde está.
## MODULE 07: ...
### FUNCTION
### SUB-MODULE: SKILL_A
#### FUNCTION
#### ROUTINE
### SUB-MODULE: SKILL_B
#### FUNCTION
#### ROUTINE
[P4]
### ASSOCIATED MEMORY
[/P4]Lo que el módulo añade alrededor son las dos cosas que en un SKILL.md no tienen dónde estar. La primera es la zona de permiso: el texto injertado queda dentro de un bloque que declara quién puede reescribirlo, y ese rechazo lo hace la app, no el modelo. La segunda es ### ASSOCIATED MEMORY, la sección donde se deposita lo que aprendes usándola — que esos pasos, en tu caso, van en otro orden; que con tus archivos esa fase no aguanta; que quieres la salida más corta. La skill sabe cómo se hace. El módulo recuerda cómo fue.
Y en un módulo cabe más de una. Si tres skills sirven al mismo oficio — leer un PDF, sacarle una tabla, escribir su resumen — puedes injertarlas en el mismo módulo, una por ### SUB-MODULE:. A partir de ahí ya no se encienden de una en una: entran en contexto juntas, cuando entra el módulo, y se ven entre ellas. Es una elección tuya, y es el momento en que dejas de hacer divulgación progresiva.
El precio está declarado: pagas las tres cada vez que ese módulo está activo, también el día en que solo necesitabas una. Lo que compras es que dejan de contradecirse — una memoria asociada en vez de tres, una regla escrita una vez en vez de la misma frase en tres sitios, y ningún trabajo a medias porque la IA había cargado una y no la otra. Si el oficio es uno, el módulo es uno. Si son tres oficios, mantenlas separadas y deja que se enciendan cuando hagan falta: es exactamente el caso en el que la skill por sí sola hace su trabajo mejor que así.
Una cosa la haces a mano, hoy, y conviene saberlo antes: el injerto es un copiar y pegar, y desde ese momento la copia es tuya. Si el autor de la skill publica una versión nueva, decides tú si la traes dentro — el texto está ahí a la vista, dentro de tu archivo, y se actualiza como se actualiza un archivo. Es el mismo pacto que el resto: debajo de ti no se mueve nada que no puedas ver.
Es lo que vale la pena decir incluso a quien nunca usará IllAIra. Una Skill sabe cómo se hace. El módulo que la aloja registra cómo fue: que con tus archivos ese paso no se sostiene, que la salida la quieres más corta, que esos pasos contigo van en otro orden. El procedimiento y la experiencia del procedimiento, en el mismo objeto, con permisos distintos — el primero en una zona que el modelo no reescribe, la segunda en una zona donde añade por sí solo.
Así la Skill no cambia, y el módulo sí: alrededor del procedimiento crece una memoria operativa, la historia de cómo esa capacidad se ha usado contigo, al alcance del modelo cada vez que el módulo está activo. Es la misma forma que ves en la Sphere Grid cuando un archivo entero se convierte en la memoria asociada de un nodo — allí un wiki, aquí un procedimiento: lo que has reunido usándola, colgado de lo que sabe hacer.
Cierto, y es la razón por la que está publicado. Un Reminder es markdown: lo abres con cualquier editor, lo lees sin nosotros, lo modificas sin permiso. No hay un entorno de ejecución que deba mantenerse en pie para que ese archivo siga valiendo. Si mañana IllAIra desapareciera, tú seguirías teniendo tus archivos y funcionarían igual — cosa que no se puede decir de una memoria que vive dentro del servicio de otro.
Funciona, un tiempo. Después crece, y descubres las tres cosas que le faltan: no puedes cambiar un trozo sin releerlo entero, no puedes declarar que una parte es intocable, y no puedes mirarlo — es un muro de texto, no un mapa. Un Reminder es la misma idea con una estructura encima, y es la estructura la que permite el resto.
Puede, y es la mejor manera de equivocarse — porque casi funciona. Pero sigue siendo algo que se carga cuando la IA juzga que el momento es pertinente, y nadie le ha dicho que de sí misma no se puede reescribir nada. Obtienes un carácter intermitente y sin defensas: parece identidad hasta que hace falta que lo sea.
Buena pregunta, y la respuesta honesta es: puedes hacerlo a mano, gratis, y nadie te lo impide. El Estándar está publicado a propósito. Lo que vendemos es el resto — la Sphere Grid para ver lo que has construido, las zonas de permiso que la app hace respetar de verdad, los Reminders ya escritos por quien lo hace de oficio, el rastreo de lo que se ha usado. El formato no: ese es tuyo igualmente.
Nadie, y quien te diga lo contrario te está vendiendo algo. Un Reminder es texto que la IA lee: lo respeta en la medida en que respeta las instrucciones, es decir casi siempre pero no por contrato. Vale igual para una Skill, para un prompt de sistema y para cualquier otra cosa que le pongas delante.
Lo que sí podemos garantizar es la otra mitad, que además es la que cuenta: la app no escribe donde la zona dice que no, y ese rechazo no pasa por el modelo. Su parte es una convención declarada; la nuestra es código que se puede leer.
Como con lo demás: los modelos se entrenan, y aprenden solos a respetar lo que dan por asentado como funciona. El único modo de que lo respeten también fuera de la app — en un chat, en otra herramienta — es usarlos. Cuanto más el método está a la vista y en uso, más se convierte en lo que un modelo espera encontrar. No es una garantía escrita en un contrato. Es el modo en que las convenciones se vuelven costumbre, para un modelo como para una persona.
El coste de marcharse es: coge los archivos. Son .md, ya están en tu dispositivo, y la exportación ZIP es un clic. No hay base de datos que exportar, no hay formato propietario que convertir, no hay historial que se quede de este lado. Preguntarse «¿y si luego quiero salir?» es la pregunta correcta que hacerle a cualquiera — y nuestra respuesta es que ya estás fuera: los archivos nunca fueron nuestros.
Sí, y no es poco. Es exactamente el motivo por el que la estructura es modular: el Telar con la identidad está siempre, los módulos se añaden cuando hacen falta y se quitan cuando ya no. Quien quiere el mínimo se queda con el Telar y nada más. Quien lo quiere todo lo paga todo, y lo sabe — pero no a un proveedor: esos tokens caben en los planes gratuitos, y cuando uno se agota, el mismo archivo se abre en el siguiente.
Sí. Menos de lo que parece — un título, unos núcleos, unos módulos — pero no cero, y no fingimos lo contrario: abrir una conversación y escribir es más rápido, el primer día. La diferencia se ve el trigésimo, cuando esa conversación no recuerda nada y el archivo sí.
Una Skill es algo que tu IA sabe hacer. Un Reminder es quién es mientras lo hace. Quédate con las dos: no se pisan, porque no están en el mismo sitio.