Se você usa o Claude, conhece as Skills: pastas com um arquivo de instruções que a IA carrega quando precisa. Elas se parecem com um Reminder o bastante para fazer você pensar “isso eu já tenho”. Não fazem o mesmo trabalho, e a diferença cabe em uma linha: uma Skill responde como algo é feito, um Reminder responde quem está fazendo.
A objeção, dita antes que você pense nela
Verdade em todos os pontos, e não vamos fugir disso. Uma Skill é uma pasta com um SKILL.md dentro: duas linhas de front matter — um nome e uma descrição — e depois texto. É markdown, é seu, vive no git, e se você mudar de ideia amanhã, leva junto. Ninguém prendeu você a nada.
O mecanismo também é bem desenhado. Enquanto a Skill não é necessária, só a descrição dela fica na memória — umas cem palavras; o corpo é carregado quando a IA decide que é relevante, e os arquivos de apoio só se ela de fato os abrir. Chama-se divulgação progressiva, e é o jeito certo de dar cem competências a uma IA sem pagar por todas elas em cada frase.
Então não: esta página não existe para dizer que as Skills são mal feitas. Ela existe porque esse mecanismo, que para uma capacidade é uma virtude, para uma identidade é o defeito.
Uma Skill entra quando é necessária. Essa é toda a sua elegância: não ocupa espaço até haver um motivo, e a IA reconhece o motivo lendo a descrição. Perfeita para “montar uma apresentação segundo as nossas regras”, algo de que se precisa na terça e não na quinta.
Uma identidade não funciona assim. Quem você é não é uma competência que liga quando o assunto pede: é aquilo que já está lá antes de você abrir a boca, e decide como você lê a pergunta. Algo que só aparece quando é chamado não é um caráter, é um manual.
É a mesma diferença que existe entre saber cozinhar e estar com fome. O primeiro é tirado da gaveta quando necessário; o segundo move você mesmo quando você não está pensando em comida.
Em um SKILL.md não existe jeito de escrever você não pode reescrever esta parte. Isso não é descuido: uma Skill é algo que você dá à IA para que ela use, e não há nada a defender.
Em um Reminder, por outro lado, há alguém que lê, entende e pode reescrever — e por isso cada bloco declara quanto dele é seu: das regras que só você pode mudar até as anotações que a IA atualiza sem perguntar. É a diferença entre um manual e uma constituição, e é também por isso que o Reminder tem uma estrutura em vez de ser prosa.
| Uma Skill | Um Reminder | |
|---|---|---|
| O que responde | como se faz uma coisa | quem é quem a faz |
| Quando entra no contexto | quando a IA julga que é relevante | sempre, desde a primeira linha |
| O que contém | um procedimento, alguns exemplos, alguns scripts | núcleos, módulos, memórias, permissões |
| Quem pode reescrevê-lo | você, fora da conversa | depende da zona: está declarado dentro do arquivo |
| Se você o tirar | a IA deixa de saber fazer aquela coisa | a IA deixa de ser alguém |
| O que ela lembra | nada: amanhã é igual a hoje | como foi: na memória associada do módulo |
Não é uma coisa ou outra, e não vale a pena transformar nisso. A divisão que funciona é limpa: Skills para as capacidades, o Reminder para a identidade. Mesma conversa, sem conflito — porque elas não disputam o mesmo lugar.
Com agentes de programação a mesma divisão já tem casa: o arquivo que o agente lê ao iniciar — CLAUDE.md, AGENTS.md — é onde vai a identidade, e as Skills continuam sendo os procedimentos que essa identidade sabe executar.
E a fronteira é mais porosa do que parece. Uma Skill que você já tem se traduz em um módulo, quase linha por linha: não há nada a reinventar, porque as duas formas respondem às mesmas quatro perguntas.
Vale também no sentido contrário, e essa é a parte surpreendente. O que é obrigatório em um SKILL.md são duas linhas de front matter — um nome e uma descrição. Abaixo disso você é livre: ninguém prescreve a estrutura do corpo. Que as Skills costumem ser escritas como prosa solta é um hábito difundido, não uma regra — e as próprias diretrizes da Anthropic recomendam passos numerados, modelos de saída e exemplos, que é exatamente a forma que um módulo já tem. Cabe sob o front matter sem reescrever nada.
Só uma coisa não atravessa, e vale dizer. Dentro de um módulo a linha que declara você não reescreve esta parte tem um lugar, e o app a faz valer; dentro de um SKILL.md essa linha não tem onde ficar, e nenhum app está no circuito para defendê-la — os marcadores de zona continuam ali como texto, e ninguém os aplica. Traduzir uma capacidade funciona perfeitamente. Traduzir identidade, não: e é só isso que esta página está dizendo.
Traduzir uma Skill em um módulo é um caminho. O outro é não traduzi-la de jeito nenhum. O corpo de um SKILL.md é markdown, e um módulo o hospeda exatamente como está, sob uma linha que declara de quem é aquele pedaço: no Standard ela se chama ### SUB-MODULE:, e embaixo dela vai o texto inteiro da Skill — a função, os passos, os exemplos. Nada é reescrito. Você declara de quem é e onde fica.
## MODULE 07: ...
### FUNCTION
### SUB-MODULE: SKILL_A
#### FUNCTION
#### ROUTINE
### SUB-MODULE: SKILL_B
#### FUNCTION
#### ROUTINE
[P4]
### ASSOCIATED MEMORY
[/P4]O que o módulo acrescenta ao redor são as duas coisas que um SKILL.md não tem onde pôr. A primeira é a zona de permissão: o texto enxertado fica dentro de um bloco que declara quem pode reescrevê-lo, e essa recusa quem faz é o app, não o modelo. A segunda é ### ASSOCIATED MEMORY, a seção onde se assenta o que você aprende usando-a — que esses passos, para você, vão em outra ordem; que com os seus arquivos aquela etapa não se sustenta; que você quer a saída mais curta. A Skill sabe como se faz. O módulo lembra como foi.
E um módulo comporta mais de uma. Se três Skills trabalham no mesmo ofício — ler um PDF, extrair uma tabela dele, escrever o resumo — você pode enxertá-las no mesmo módulo, uma por ### SUB-MODULE:. A partir daí elas não se acendem mais uma de cada vez: entram no contexto juntas, quando o módulo entra, e enxergam umas às outras. É uma escolha sua, e é o momento em que você deixa de fazer revelação progressiva.
O preço é declarado: você paga pelas três toda vez que aquele módulo está ativo, inclusive no dia em que só precisava de uma. O que você compra é que elas param de se contradizer — uma memória associada em vez de três, uma regra escrita uma vez em vez da mesma frase em três lugares, e nenhum trabalho deixado pela metade porque a IA tinha carregado uma delas e não a outra. Se o ofício é um, o módulo é um. Se são três ofícios, mantenha-os separados e deixe que se acendam quando preciso: esse é exatamente o caso em que uma Skill sozinha cumpre seu papel melhor do que isto.
Uma coisa que hoje você faz à mão, e vale saber de antemão: o enxerto é um copiar e colar, e a partir daquele momento a cópia é sua. Se o autor da Skill publicar uma nova versão, é você quem decide se a traz — o texto está ali à vista, dentro do seu arquivo, e se atualiza do jeito que um arquivo se atualiza. É o mesmo acordo de todo o resto: nada se move debaixo de você sem que você possa ver.
É o que vale a pena dizer até para quem nunca vai usar a IllAIra. Uma Skill sabe como se faz uma coisa. O módulo que a hospeda registra como foi: que com os seus arquivos aquele passo não se sustenta, que você quer a saída mais curta, que com você esses passos vão em outra ordem. O procedimento e a experiência do procedimento, no mesmo objeto, com permissões diferentes — o primeiro em uma zona que o modelo não reescreve, o segundo em uma zona onde ele acrescenta por conta própria.
Assim a Skill não muda, e o módulo muda: em torno do procedimento cresce uma memória operacional, a história de como aquela capacidade foi usada com você, ao alcance do modelo toda vez que o módulo está ativo. É a mesma forma que você vê na Sphere Grid quando um arquivo inteiro vira a memória associada de um nó — ali uma wiki, aqui um procedimento: o que você juntou usando-o, pendurado no que ele sabe fazer.
É verdade, e é por isso que ele é publicado. Um Reminder é markdown: você o abre com qualquer editor, lê sem a gente, altera sem pedir licença. Não há nenhum runtime que precise ficar no ar para que esse arquivo continue significando alguma coisa. Se a IllAIra sumisse amanhã, você ainda teria seus arquivos e eles funcionariam do mesmo jeito — o que não se pode dizer de uma memória que mora dentro do serviço de outra pessoa.
Funciona, por um tempo. Depois ele cresce, e você descobre as três coisas que lhe faltam: não dá para mudar um pedaço sem reler tudo, não dá para declarar que uma parte é intocável, e não dá para olhar para ele — é um paredão de texto, não um mapa. Um Reminder é a mesma ideia com uma estrutura por cima, e é a estrutura que torna o resto possível.
Pode, e essa é a melhor maneira de errar — porque quase funciona. Mas ela continua sendo algo que carrega quando a IA julga o momento relevante, e ninguém disse a ela que nada sobre si mesma pode ser reescrito. Você ganha um personagem intermitente e sem defesas: parece identidade até o momento em que precisaria ser.
Pergunta justa, e a resposta honesta é: você pode fazer à mão, de graça, e ninguém está te impedindo. O Standard é publicado de propósito. O que vendemos é o resto — a Sphere Grid para ver o que você construiu, as zonas de permissão que o app realmente faz valer, Reminders já escritos por quem faz isso como profissão, o rastreamento do que foi usado. Não o formato: esse é seu de qualquer jeito.
Ninguém, e quem diz o contrário está te vendendo alguma coisa. Um Reminder é texto que a IA lê: ela o respeita na medida em que respeita instruções, o que é quase sempre, mas não por contrato. Vale o mesmo para uma Skill, para um system prompt e para qualquer outra coisa que você ponha na frente dela.
O que podemos garantir é a outra metade, que também é a que conta: o app não escreve onde a zona diz não, e essa recusa não passa pelo modelo. A parte dele é uma convenção declarada; a nossa é código que você pode ler.
Como com todo o resto: os modelos são treinados, e aprendem sozinhos a respeitar o que conhecem como estabelecido — como as coisas funcionam. O único jeito de eles a honrarem também fora do app — em um chat, em outra ferramenta — é usá-la. Quanto mais o método está à vista e em uso, mais ele se torna aquilo que um modelo espera encontrar. Não é uma garantia escrita em contrato. É como as convenções viram hábito, para um modelo como para uma pessoa.
O custo de sair é: levar os arquivos. São .md, já estão no seu dispositivo, e a exportação em ZIP é um clique. Não há banco de dados para exportar, formato proprietário para converter, histórico que fique do nosso lado. Perguntar “e se eu quiser sair depois” é a pergunta certa a fazer a qualquer um — e a nossa resposta é que você já saiu: os arquivos nunca foram nossos.
Sim, e não é pouco. É exatamente por isso que a estrutura é modular: o Tear com a identidade está sempre lá, os módulos entram quando precisam e saem quando não precisam. Quem quer o mínimo fica com o Tear e mais nada. Quem quer tudo paga por tudo, e sabe disso — mas não a um provedor: esses tokens cabem nos planos gratuitos, e quando um se esgota o mesmo arquivo abre no seguinte.
Sim. Menos do que parece — um título, alguns núcleos, alguns módulos — mas não é nada, e não fingimos o contrário: abrir um chat e digitar é mais rápido, no primeiro dia. A diferença aparece no trigésimo dia, quando aquele chat não lembra de nada e o arquivo lembra.
Uma Skill é algo que a sua IA sabe fazer. Um Reminder é quem ela é enquanto faz. Fique com os dois: eles não se atrapalham, porque não estão no mesmo lugar.