# Não é uma Skill > Claude Skills, instruções de GPT personalizado, Gems: fazem um trabalho diferente do de um Reminder. Uma diz como algo é feito, o outro diz quem está fazendo. Prós, contras e onde os dois convivem. *versão com design: https://illaira.com/pt/approfondimenti/non-e-una-skill · índice: https://illaira.com/pt/llms.txt* --- [Ir para o conteúdo](#contenuto) [← Aprofundamentos](https://illaira.com/pt/approfondimenti.md) Aprofundamento 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 ## “As Skills são oficiais, e já são arquivos meus” 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**. ## O ponto é quando ela entra no contexto 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. ## E há uma coisa que uma Skill não tem 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. [Como funcionam as zonas de permissão →](https://illaira.com/pt/approfondimenti/zone-di-permesso.md) ## Em duas colunas | | 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 | ## Onde elas ficam juntas, o que acontece quase sempre 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. A descrição: o que faz e quando usar ### FUNCTION · ### TRIGGER As instruções, os passos a seguir ### ROUTINE O que não fazer, os limites ### LIMITI Os exemplos de entrada e de saída ### ESEMPIO 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. [Como funciona com agentes de programação →](https://illaira.com/pt/agenti.md) ## O terceiro caminho: não traduzir, enxertar 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 módulo contém a Skill e a potencializa É 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. [O seu arquivo inteiro, aqui, é um nó →](https://illaira.com/pt/approfondimenti/non-e-un-grafo-di-note.md) ## As objeções, uma a uma ### “O seu não é o padrão oficial de ninguém” É 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. ### “Um system prompt longo resolveria” 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. ### “Uma Skill também pode guardar uma personalidade” 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. ### “É só markdown: o que vocês estão me vendendo?” 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. ### “Quem garante que a IA vai respeitar?” **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. ### “Vocês estão me prendendo ao seu formato” 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. ### “Isso gasta tokens em toda conversa” 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. ### “Eu preciso aprender um formato” 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. [O Standard na íntegra, e o repositório público →](https://illaira.com/pt/documentazione.md) ## Em uma linha 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. [Pegue um Reminder](https://illaira.com/pt/bazar.md) · [Onde você o carrega](https://illaira.com/pt/approfondimenti/dove-caricare.md)