If you use Claude you know Skills: folders with an instruction file the AI loads when needed. They resemble a Reminder enough to make you think «I already have that». They don't do the same job, and the difference shows in one line: a Skill answers how a thing is done, a Reminder answers who is doing it.
The objection, said before you think it
True across the board, and we won't dance around it. A Skill is a folder with a SKILL.md inside: two lines of front matter — a name and a description — and then text. It's markdown, it's yours, it lives in git, and if you change your mind tomorrow you take it with you. Nobody has locked you into anything.
The mechanism is well designed too. Until the Skill is needed, only its description stays in memory — a hundred words or so; the body loads when the AI decides it's relevant, and the supporting files only if it actually opens them. It's called progressive disclosure, and it's the right way to give an AI a hundred competences without paying for all of them in every sentence.
So no: this page doesn't exist to tell you Skills are badly made. It exists because that mechanism, which for a capability is a virtue, for an identity is the flaw.
A Skill enters when it's needed. That's its whole elegance: it takes no room until there's a reason, and the AI recognises the reason by reading the description. Perfect for «lay out a presentation to our rules», which is needed on Tuesday and not on Thursday.
An identity doesn't work that way. Who you are isn't a competence that switches on when the topic calls for it: it's the thing that is already there before you open your mouth, and it decides how you read the question. Something that appears only when invoked isn't a character, it's a manual.
It's the same difference as between knowing how to cook and being hungry. The first is pulled out when required; the second moves you even when you aren't thinking about food.
In a SKILL.md there is no way to write you may not rewrite this part. That isn't an oversight: a Skill is something you give the AI so it will use it, and there's nothing to defend.
In a Reminder, on the other side, there's somebody who reads, understands and might rewrite — and so every block declares how much of it is yours: from the rules only you can change down to the notes the AI updates without asking. It's the difference between a manual and a constitution, and it's also why the Reminder has a structure instead of being prose.
| A Skill | A Reminder | |
|---|---|---|
| What it answers | how a thing is done | who the one doing it is |
| When it enters context | when the AI judges it relevant | always, from the first line |
| What it holds | a procedure, some examples, some scripts | nuclei, modules, memories, permissions |
| Who may rewrite it | you, outside the conversation | depends on the zone: it is declared inside the file |
| If you take it away | the AI stops knowing how to do that thing | the AI stops being someone |
| What it remembers | nothing: tomorrow is the same as today | how it went: in the module’s associated memory |
It isn't either/or, and it isn't worth making it so. The division that works is clean: Skills for capabilities, the Reminder for identity. Same conversation, no conflict — because they aren't competing for the same place.
With coding agents the same division already has a home: the file the agent reads on startup — CLAUDE.md, AGENTS.md — is where the identity goes, and Skills remain the procedures that identity knows how to run.
And the boundary is more porous than it looks. A Skill you already have translates into a module, almost line by line: there's nothing to reinvent, because the two forms answer the same four questions.
It holds the other way too, and that's the surprising part. What's mandatory in a SKILL.md is two lines of front matter — a name and a description. Below that you're free: nobody prescribes the structure of the body. That Skills tend to be written as loose prose is a widespread habit, not a rule — and Anthropic's own guidelines recommend numbered steps, output templates and examples, which is exactly the shape a module already has. It fits under the front matter without rewriting.
One thing alone doesn't cross over, and it's worth saying. Inside a module the line declaring you don't rewrite this part has a home, and the app enforces it; inside a SKILL.md that line has nowhere to sit, and no app is in the loop to defend it — the zone markers stay there as text, and nobody applies them. Translating a capability works perfectly. Translating identity doesn't: and that's all this page is saying.
Translating a Skill into a module is one road. The other is not translating it at all. The body of a SKILL.md is markdown, and a module hosts it exactly as it is, under a line that declares whose that piece is: in the Standard it is called ### SUB-MODULE:, and under it goes the Skill’s whole text — its function, its steps, its examples. Nothing gets rewritten. You state whose it is, and where it sits.
## MODULE 07: ...
### FUNCTION
### SUB-MODULE: SKILL_A
#### FUNCTION
#### ROUTINE
### SUB-MODULE: SKILL_B
#### FUNCTION
#### ROUTINE
[P4]
### ASSOCIATED MEMORY
[/P4]What the module adds around it are the two things a SKILL.md has nowhere to put. The first is the permission zone: the grafted text lands inside a block that declares who may rewrite it, and that refusal is made by the app, not by the model. The second is ### ASSOCIATED MEMORY, the section where what you learn using it settles — that those steps, for you, go in a different order; that with your files that one stage does not hold; that you want the output shorter. The Skill knows how it is done. The module remembers how it went.
And a module holds more than one. If three Skills work the same trade — read a PDF, pull a table out of it, write its summary — you can graft them into the same module, one per ### SUB-MODULE:. From then on they no longer light up one at a time: they enter context together, when the module does, and they can see each other. It is your choice, and it is the moment you stop doing progressive disclosure.
The price is stated: you pay for all three every time that module is active, including the day you only needed one. What you buy is that they stop contradicting each other — one associated memory instead of three, one rule written once instead of the same sentence in three places, and no job left half done because the AI had loaded one of them and not the other. If the trade is one, the module is one. If there are three trades, keep them apart and let them light up when needed: that is exactly the case where a Skill on its own does its job better than this.
One thing you do by hand today, and it is worth knowing up front: the graft is a copy and paste, and from that moment the copy is yours. If the Skill’s author publishes a new version, you decide whether to bring it in — the text sits there in plain sight, inside your file, and it updates the way a file updates. It is the same deal as the rest: nothing moves underneath you that you cannot see.
It is the thing worth saying even to whoever will never use IllAIra. A Skill knows how a thing is done. The module that hosts it records how it went: that with your files that step does not hold, that you want the output shorter, that with you those steps go in a different order. The procedure and the experience of the procedure, in the same object, with different permissions — the first in a zone the model does not rewrite, the second in a zone where it appends on its own.
So the Skill does not change, and the module does: around the procedure grows an operational memory, the history of how that capability has been used with you, within the model’s reach every time the module is active. It is the same shape you see in the Sphere Grid when an entire archive becomes the associated memory of a node — there a wiki, here a procedure: what you gathered using it, hanging from what it knows how to do.
True, and that's why it's published. A Reminder is markdown: you open it with any editor, you read it without us, you change it without permission. There's no runtime that has to stay up for that file to keep meaning something. If IllAIra disappeared tomorrow, you'd still have your files and they'd work the same — which can't be said of a memory living inside somebody else's service.
It works, for a while. Then it grows, and you find the three things it lacks: you can't change one piece without re-reading all of it, you can't declare that a part is untouchable, and you can't look at it — it's a wall of text, not a map. A Reminder is the same idea with a structure on top, and it's the structure that makes the rest possible.
It can, and that's the best way to get it wrong — because it almost works. But it stays something that loads when the AI judges the moment relevant, and nobody has told it that nothing about itself may be rewritten. You get an intermittent character with no defences: it looks like identity until it needs to be.
Fair question, and the honest answer is: you can do it by hand, free, and nobody is stopping you. The Standard is published on purpose. What we sell is the rest — the Sphere Grid to see what you've built, the permission zones the app actually enforces, Reminders already written by people who do it for a living, the tracing of what was used. Not the format: that's yours either way.
Nobody, and anyone telling you otherwise is selling you something. A Reminder is text the AI reads: it respects it as far as it respects instructions, which is nearly always but not by contract. The same holds for a Skill, for a system prompt, and for anything else you put in front of it.
What we can guarantee is the other half, which is also the half that counts: the app doesn't write where the zone says no, and that refusal doesn't go through the model. Its part is a declared convention; ours is code you can read.
As with everything else: models train, and they learn on their own to respect what they know as established — as how things work. The only way they will honour it outside the app as well — in a chat, in another tool — is to use them. The more the method stands in the open and in use, the more it becomes what a model expects to find. It is not a guarantee written into a contract. It is how conventions become habit, for a model as for a person.
The cost of leaving is: take the files. They're .md, they're already on your device, and the ZIP export is one click. There's no database to export, no proprietary format to convert, no history that stays on our side. Asking «and what if I want out later» is the right question to ask anyone — and our answer is that you're already out: the files were never ours.
Yes, and not a trivial amount. That’s exactly why the structure is modular: the Loom with the identity is always there, modules are added when needed and removed when they aren’t. Whoever wants the minimum keeps the Loom and nothing else. Whoever wants everything pays for everything, and knows it — but not to a provider: those tokens fit in the free plans, and when one runs dry the same file opens on the next.
Yes. Less than it looks — a title, some cores, some modules — but not nothing, and we don't pretend otherwise: opening a chat and typing is faster, on day one. The difference shows on day thirty, when that chat remembers nothing and the file does.
A Skill is something your AI knows how to do. A Reminder is who it is while doing it. Keep both: they don't tread on each other, because they aren't in the same place.