Skills are the “instructions and tools” that teach the AI to work with your project. On its own, an AI model knows only what you tell it about you and your business. Skills collect that knowledge in one place: the task description, documents, examples, and ready-made scripts. Instead of spending time on explanations in every new conversation, you create a skill once — and from then on the AI already knows what to do and how.
Why this matters: context
AI models have a limited “working memory” — the context window: a fixed amount of text the model can consider at once. Everything you want the AI to know about your task must fit inside that limit. That is why managing context is the single biggest factor in good results.
Two opposite problems lie in wait:
- Too little context — if the AI does not have enough information about your project and goals, it starts guessing and hands you a wrong result;
- Too much context — if you load everything into memory at once, the model’s attention spreads thin across a pile of topics, and it starts making mistakes on the part that matters.
The goal is to give the model exactly the information the task at hand needs — no more, no less. That is exactly what skills are for.
CLAUDE.md — the default memory
By default, the file CLAUDE.md is loaded at the start of every chat — a plain text file with the project’s rules. It usually holds the most general things: what the project is, how it is built, and which rules the AI must always follow.
For universal rules this approach works well. But as the project grows and different tasks appear — editing the site, working with the database, publishing changes, analytics — piling everything into one file stops working: you get exactly the “too much context” problem. The model spends its attention on deployment rules while you are asking it to fix a page.
What is a skill?
A skill is a dynamic replacement for one “monolithic” file. Instead of a single large document, you create a collection of focused skills — each one about its own type of task. Start a new chat, and only the skill needed for the current work is loaded.
A skill is not one file but a whole folder:
SKILL.md— the main file with the instructions; this is what loads into the AI’s memory when the skill is activated;- Documentation — reference materials, examples, templates;
- Scripts — ready-made programs (in Python, for example) that automate typical actions;
- Examples — samples of what a good result should look like.
Everything tied to one type of task lives in one place: the documentation tells the AI what to do, the scripts give it the tools to do it, and the examples show what to aim for.
Where they are stored
Skills live in the project folder .claude/skills/{skill-name}/ and are stored together with the project in Git — the shared history of changes. Skill edits and project code share one history: every sync or version switch applies to both at once.
How to improve skills
The best way is not to edit skills by hand but to ask the AI to do it itself. Spot a mistake — say: “fix this, then add a rule to the skill so it never happens again.” The AI applies the fix and updates the skill in that very session.
Improvement moves fast, especially at the start:
- Out of the box — the AI works with no knowledge of your project. Results are generic and often imprecise;
- After 20–30 improvements — most tasks usually reach about 85% accuracy. This is where the easiest and most visible wins are;
- After 100+ improvements — quality gets close to flawless even for tasks that are hard to describe with strict rules.
The main rule when you ask the AI to update skills: keep edits small and skill files short. Every update should change only what is needed — a few lines, not a full rewrite. Models tend to pad every rule with extra explanations, so the skill “blobs out” and fits into the context worse. Ask explicitly to keep changes minimal.
A skill is a property of the chat
A skill is attached to the chat the same way the model is: each chat stores the selected value, restores it when opened, and passes it on when a new chat is created. Choosing “no skill” is a full value in its own right, not a missing setting: in the interface it is the No skill item, listed first among the skills.
- Selection in the chat — the selector in the input area shows the list of skills with their colors, the No skill item, and a button that jumps to skill management. Open a chat, and the selector restores its skill — including No skill;
- Saving — the selected value sticks to the current chat and at the same time becomes the default for new chats;
- Inheritance — a new chat created from the current one (the button that continues in a new chat, a duplicate in Telegram) inherits its skill, including No skill; a new chat from the chat list takes the skill of the last active chat;
- A skill known in advance — tasks, bots, Telegram, and the chat-creation API accept the skill as a separate field (for example, the
chats/createrequest with theskillparameter); - Buttons — a button can name a skill explicitly with the
skill="…"attribute: the chat created from it opens with that skill; without the attribute, the new chat inherits the skill of the chat where the button was clicked; - Chat list — next to the model, the chat’s skill is shown (“model • skill” in the skill’s color); chats without a skill show only the model.
Changing the skill in the current chat is saved by the server and applies to the messages that follow; for the built-in MiniAgent backend it applies from the next session, because its system prompt is fixed when the session is created (see the MiniAgent — the built-in agent page). Old chats created before this feature got their skill automatically: from the first recorded skill load in the chat’s history, or the No skill value when there was none.
Automatic skill loading
Earlier, to load a skill, the command “start with loading skill {name}” was inserted at the top of the chat’s first message: it landed in the saved message, affected the chat title, and got in the way when copying or editing. Now loading is fully automatic: the requirement reaches each backend through its own out-of-band channel — a system prompt line, a launch flag, an environment variable, or a file tied to the chat. Your message stays clean.
How the requirement travels across all ten backends (verified on a live system):
| Backend | How the requirement is delivered | How skills are found |
| Claude Code | launch flag --append-system-prompt (every turn) | native reading of .claude/skills |
| MiniAgent | a line in the system prompt (MiniAgentOptions.Skill) | native — the load_skill tool |
| Codex | flag -c developer_instructions=… (every turn) | native; a pointer to the skills folder inside the line |
| OpenCode | the OPENCODE_CONFIG_CONTENT variable → the chat’s instruction file | native scanning of .claude/skills |
| Pi | flag --append-system-prompt (chat process) | none ⇒ a pointer to the skills folder inside the line |
| Oh My Pi | the same --append-system-prompt flag | none ⇒ a pointer to the skills folder inside the line |
| DeepSeek Harness | the DSH_SYSTEM_PROMPT variable (persona + line, on every launch) | none ⇒ a pointer to the skills folder inside the line |
| Kimi Code | flag --agent-file (a ${base_prompt} wrapper; applied when the session is created) | its own directories only ⇒ a pointer to the skills folder inside the line |
| Reasonix | the REASONIX.md file + the [skills] paths line in config.toml (each chat has its own directory) | native via [skills] paths |
| Command Code | flag --mod (the appendSystemPrompt hook, every turn) | the --skill flag — an extra skills root for the chat |
The files created for these channels (OpenCode, Kimi Code, Reasonix, Command Code) live in the agent’s home directory under chats/chat-{id}/ — one file per chat. There are no shared files on the machine or inside the project: different chats with different skills never interfere with each other, and a chat with no skill gets nothing created at all.
What the agent gets on loading
What enters the context is not a command line but the skill’s full contents: SKILL.md with all its instructions and every file in the skill folder — documentation, scripts, examples. The whole .claude/skills directory stays available to the agent as well: when needed, it can open other skills too. MiniAgent additionally lists the available skills in its system prompt, and its load_skill tool loads a chosen skill on the spot.
What changed for you
- Clean prompts — messages, chat titles, copying, and editing no longer carry the service command that loaded the skill;
- Correct titles — the chat name is derived from your first message;
- Switching skills mid-conversation — a new skill applies from the next messages on (for MiniAgent, Kimi Code, and Reasonix — from the next session).
Managing skills
The skills dialog lets you browse, edit, create, and organize skills. It is split into two panels: the list of all skills on the left, and the editor of the selected skill on the right.
The skill list filters by name (type to search), and the dialog remembers the last selected skill and the open file between openings; next to a name in the list there is a pencil button that opens the dialog straight at that skill, right from the chat’s selector.
Every skill has its own color for quick visual recognition in the selector and the chat lists. Colors are stored in the .xedant/skills.yml file — one entry per skill (the color field); the file takes part in project validation and syncs between devices: change it on one, and every other device picks the change up instantly.
The skill files themselves live in .claude/skills/{skill-name}/ inside the project and are committed to Git together with it.
Every skill that has a SKILL.md file is always active and visible in the selector — there is no separate “off” switch.
- Renaming — the Rename Skill item in the actions menu: type a new name, and the skill folder, the name inside
SKILL.md, and the references to it in tasks and bots update automatically; - Copy and paste — a whole skill (name, color, and all files) is copied to the clipboard and pasted back. Pasting over an existing skill merges the files: the ones present are overwritten, missing ones are added, the rest are left alone; if the clipboard holds no
SKILL.md, it is restored automatically; - Export and import — one skill or all of them at once are exported as a JSON file (name, description, files, timestamp). Importing a name that is already taken creates the new skill under a name with a timestamp, leaving the original untouched;
- Live updates — any change to the skills (edits in the editor, changes coming from Git, the agent’s own actions) instantly reaches every open window and tab: the skill lists and the chat selector refresh themselves, and an open editor does not reset.
The skill editor
The editor in the right panel shows all the skill’s files as tabs. The first tab is always SKILL.md, the main instruction file that loads into the AI’s memory. The other tabs are the other files in the skill folder.
What the editor can do:
- Tabs — quick jumps between all the skill’s files;
- Syntax highlighting — comfortable color-coded display of code in scripts and settings files;
- Autosave — changes are saved as you work;
- Git integration — you can commit skill changes into the project’s history right from the editor.
Skill edits are tracked by the same Git store as the project: in the Git panel, skill changes appear next to code changes — one shared history.
The editor can run scripts straight from the skill folders. That is handy for routine operations — publishing changes, working with the database, builds. It is also safe: sensitive data (passwords, access keys, database connection strings) lives at the project-model level, not inside the skill.
Still, try not to edit skill files and scripts by hand. Train yourself (and the models themselves) to create and update skills through the AI — for example with the skill-management skill demo.skills. The model understands the structure and formatting rules better, while manual edits quietly drift in different directions.
Skill analytics
Because the skill is stored on every chat, the per-skill statistics are exact: the Skills section on the Analytics page shows three charts for the selected period — tokens by skill, cost by skill, and total chat time by skill. Chats without a skill are combined into a separate “No skill” series.