# Claude Code Skills in 2026: how to build a skills library for yourself > How to create Claude Code Skills: SKILL.md structure, the description formula, ready-made collections from Anthropic, and anti-patterns. Step by step in 30 minutes. Source: https://ailoot.ai/blog/en/claude-code-skills-library/ Canonical: https://ailoot.ai/blog/en/claude-code-skills-library/ Language: en Publisher: Ailoot (https://ailoot.ai/) Translation: guide-213 Revision: sha256-75a39b9339a79319ac5045ebc690bce262779b8a7b83b6e08145f8a87717f85a
Key points Claude Code Skills are folders containing a SKILL.md file that Claude loads into context only when needed. CLAUDE.md stays in memory all the time and consumes the token budget, while a skill loads on a trigger—and dozens of skills can easily coexist in one project. The most important part of a skill is its description: Claude uses it to decide whether to activate the skill. In this article, I explain the SKILL.md structure, the description formula, ready-made collections, and how to build your first skill in 30 minutes.
[Ailoot documentation: API, keys, and setup](https://ailoot.ai/docs/). ## What Is a Skill in Claude Code, and Why Isn't It Just “A Bigger Prompt”?
Key points A skill is a directory containing a SKILL.md file that describes when and how to apply a specific methodology. Anthropic compares a skill to instructions for a new employee: you don't dictate every step every day; you give them a procedure, and they apply it themselves in the right situations. The main difference from CLAUDE.md is that a skill loads into context only when needed, so dozens of skills can live in a project without hitting the token budget.
Claude Code Skills are a native Claude Code feature that Anthropic launched in October 2025 for Pro/Max/Team/Enterprise. Later, they opened the [Agent Skills](https://agentskills.io) specification as a standard that works beyond Claude, too. In code, it's just a folder: ``` .claude/skills/ ├── deploy-to-prod/ │ ├── SKILL.md │ └── scripts/ │ └── check-migrations.sh ├── weekly-content-plan/ │ └── SKILL.md └── triage-support-tickets/ └── SKILL.md ``` Each folder is one skill. The `SKILL.md` file is Markdown with YAML frontmatter at the top and ordinary instructions below. When a user asks, “let's deploy to production,” Claude sees the description of the `deploy-to-prod` skill, recognizes the “deploy to production” trigger, loads the SKILL.md body into context, and follows the steps. ### Three Levels of Progressive Loading Anthropic built skills with progressive loading: data is loaded in layers as needed. In the Anthropic Engineering blog, the team describes this as the “core design principle that makes Agent Skills flexible and scalable” ([Anthropic Engineering](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)). The three loading levels: 1. **Metadata (always)** - when a session starts, Claude sees only the `name` and `description` of each skill. Budget: about 100 tokens per skill. 2. **Instructions (on trigger)** - when the user says something relevant, Claude loads the SKILL.md body. Budget: fewer than 5000 tokens. 3. **Resources (on request)** - bundled files (examples, templates, datasets) are fetched only when the model itself looks for them. Budget: unlimited. Previously, [CLAUDE.md](https://ailoot.ai/blog/en/claude-md-template/) had to hold everything the AI should “remember”—and a project with 50 rules quickly hit the context limit. With skills, dozens can easily coexist in one project because only their descriptions enter the initial context. ### Where Skills Live: Four Levels | Level | Path | Applies to | |------------|-----------------------------------|--------------------| | Enterprise | Managed organization settings | All company users | | Personal | `~/.claude/skills//SKILL.md` | All your projects | | Project | `.claude/skills//SKILL.md` | This project only | | Plugin | `/skills//SKILL.md` | Where the plugin is enabled | Priority: enterprise overrides personal, personal overrides project. Plugins use the `plugin-name:skill-name` namespace and do not conflict. This is convenient: put general professional skills in `~/.claude/skills/` and project-specific ones in the repository's `.claude/skills/`. ## What's Inside a SKILL.md?
Key points SKILL.md is a Markdown file with YAML frontmatter at the top and instruction text below. At minimum, it has two fields: name (up to 64 characters) and description (up to 1024 characters). The full schema includes allowed-tools, disable-model-invocation, paths, context: fork, agent, and hooks. Anthropic recommends keeping the instruction body within 500 lines and putting everything else in nearby reference files.
Here's a minimal example—twenty lines, and the skill is ready: ```yaml --- name: weekly-content-plan description: Prepares a weekly post plan for a Telegram channel and short videos. Triggers - "make a post plan", "what should I post this week", "a 7-day channel plan". Do not activate if the request is about a website or email newsletter. --- # Weekly Content Plan ## Steps 1. Read `knowledge/audience.md` - who we're writing for 2. Read `knowledge/tone-of-voice.md` - how we write 3. Read the last 10 posts in the channel - what has already been covered 4. Come up with 7 topics for the week: 3 sales-focused, 2 expert, 2 personal 5. For each, provide one hook line and three bullets about the post 6. Output as a table: day of the week | type | hook | plan ``` That's enough. If a user writes, “let's plan posts for the week,” Claude sees the trigger in the description, loads SKILL.md, reads the named files, and outputs a table. ### Limits to Keep in Mind The [official Claude API documentation](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) sets strict limits: - **`name`**: up to 64 characters, lowercase letters, numbers, and hyphens only, with no XML tags. `anthropic` and `claude` are reserved. - **`description`**: up to 1024 characters in the API; required, with no XML tags. - **Listing budget**: in Claude Code, descriptions for all skills together take up about 1% of the context window. If there are many skills, descriptions will be truncated—and the keywords Claude needs to match may disappear. - **SKILL.md body**: Anthropic recommends keeping the body within 500 lines. Move anything longer into `references/`, `scripts/`, and `examples/` files and load them through instructions. After context compaction (`/compact`), Claude retains the first 5000 tokens of each previously invoked skill; the total budget for all reattached skills is 25 000 tokens. If a skill doesn't fit, its behavior is “forgotten.” ### Full Frontmatter Schema At minimum, use `name` and `description`. Production skills also use other fields: | Field | Purpose | Example | |----|----|----| | `name` | Skill name; defaults to the folder name if omitted | `deploy-to-prod` | | `description` | Trigger for auto-invocation | See the formula below | | `when_to_use` | Additional trigger phrases | `["deploy", "let's ship it"]` | | `allowed-tools` | Which tools can be used without asking permission | `["Read", "Bash(npm run build)"]` | | `disable-model-invocation` | `true` - only the user can invoke it | For dangerous operations | | `user-invocable` | `false` - only Claude can invoke it | For background knowledge | | `paths` | Glob patterns where the skill is active | `["src/**/*.ts"]` | | `context: fork` | Run in an isolated subagent | When context is heavy | | `agent` | Subagent type to launch | `Explore`, `Plan`, `general-purpose` | | `effort` | Reasoning level | `low`, `medium`, `high`, `xhigh`, `max` | | `model` | Which model to give the skill | `claude-opus-4-7` | | `hooks` | Hooks on the skill lifecycle | See the hooks section | The `disable-model-invocation: true` field is a must-have for anything that must not run automatically. For example, a `deploy-to-prod` skill with this flag can be invoked only if the user explicitly types `/deploy-to-prod`. Without the flag, Claude could deploy because “the code looks ready.” ## Why Does Description Account for 90% of the Work, and How Do You Write One?
Key points Description is the only field Claude sees at the start of a session. If it's poorly written, the skill won't work, even if its instruction body is perfect. A good description has three parts: what it does + trigger phrases in quotes + when NOT to use it. In its own `skill-creator`, Anthropic recommends making descriptions “slightly pushy”—Claude tends to under-trigger.
The most common vibe-coder mistake is writing a description like “Helper for X.” The skill physically exists in its folder, but Claude doesn't invoke it. ### A Bad Description ```yaml description: Build dashboards. ``` What Claude can't tell: when the user asks “show me sales for the week,” is that about a dashboard or not? When the user asks for a “revenue chart,” is that about a dashboard or just a chart in general? When they ask for a “monthly report,” is that definitely not a dashboard? Anthropic's [own `skill-creator`](https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md) states the recommendation directly:

Claude currently has a tendency to 'undertrigger' skills—to not use them where they would be useful. To counter this, make skill descriptions a little 'pushy'.

— Anthropic Skill Creator (SKILL.md), https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md
### The Formula for a Good Description Three parts: 1. **What it does** - one sentence about the result, not the process. Not “generates SQL,” but “exports sales into a table for a Telegram channel.” 2. **When to trigger it** - 3-5 quoted phrases that users actually say. Don't guess; look at your chat and support history. 3. **When NOT to trigger it** - 1-2 phrases about similar tasks the skill shouldn't respond to. Without this section, two similar skills will keep conflicting. An example of a strong description from my project (simplified and anonymized): ```yaml description: | Writes and publishes an SEO guide to the blog, following the editorial policy. Triggers: "write a guide about X", "let's make a new pillar", "a blog article about Y", "build a blog guide about Z". Do not activate if the request is about an email newsletter, a Telegram post, or an internal team instruction— those are other skills. ``` What works here: - The verb “writes and publishes” instead of “helps with” specifies a concrete result. - Four trigger phrases in quotes cover different phrasings. - An English trigger is included too—if the user switches to the team's language, the skill will still work. - A separate “do not activate if” section prevents conflicts with email and post skills. ### How to Test a Description In its `skill-creator`, Anthropic built in a trigger-evals methodology: 20 prompts to check whether a skill activates. Ten should trigger it, and ten should not (including near-miss scenarios where the phrasing is similar but the task is different). In vibe-coder terms, this means: after writing the description, open a blank chat and try 5 phrases you really use, plus 3 phrases that sound similar but mean something else. If the skill doesn't activate where it should, or activates where it shouldn't, revise the description. Only then write the instruction body. ## Which Skills Would I Install First?
Key points The quickest strategy for an entrepreneur is to start with ready-made collections and customize them. Anthropic and Vercel have published public collections that can be installed with a single command and cover typical tasks such as documents and design. As of May 2026, the official `anthropics/skills` repository has ~138,000 stars.
Spending the first two weeks writing your own skills is a losing strategy. Start by installing ready-made ones and seeing how they are built; then add your own using the same approach. It's cheaper to take proven collections made by others and customize them for yourself than to build everything from scratch. Here are the collections I'd start with: ### 1. anthropics/skills - Official Collection with skill-creator Repository: [github.com/anthropics/skills](https://github.com/anthropics/skills). 138,000 GitHub stars. It contains official skills from the Anthropic team: `skill-creator` (a meta-skill that writes other skills), `claude-api` (helps build API integrations), and ready-made document skills for PowerPoint, Excel, Word, and PDF. Install with Claude Code: ```bash /plugin marketplace add anthropics/skills /plugin install document-skills@anthropic-agent-skills /plugin install example-skills@anthropic-agent-skills ``` The main value is `skill-creator`. It writes a SKILL.md based on your description, then runs 20 trigger-evals and revises the description until the skill starts activating where it should. In essence, it's “a skill for creating skills.” ### 2. vercel-labs/agent-skills - Design Without an AI Look Repository: [github.com/vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills). Its leading skill is `web-design-guidelines`, with about 133,000 weekly installations. It audits UI code against more than 100 accessibility, performance, and usability rules. Alongside it is [Anthropic frontend-design](https://github.com/anthropics/skills/tree/main/skills/frontend-design), with more than 110,000 weekly installations. It makes AI choose a style before it starts writing code. Without it, every page Claude generates has the Inter font, a purple gradient, and grid cards. The result is the same for everyone. Overall, if you install the collections on this list, your Claude Code will have dozens of ready-made skills from the first month. ## Which Repetitive Tasks Should You Turn into a Skill?
Key points The rule is simple: any action you do more than twice a week and that follows roughly the same steps is a candidate for a skill. Not a complex “once-a-year report for the auditor,” but routine work: a channel content plan, checking client receipts, a welcome email for a new participant. A skill turns a one-off effort into an asset that works without you.
In client work and other people's projects, I've seen this pattern dozens of times. Someone has “that thing they do from scratch every time.” Every Monday, they write the same kind of report. Every time a new client comes on board, they go through the same procedure. Every publication follows the same template. And each time it takes 30-90 minutes because they have to recall the steps, open the right files, and formulate the Claude prompt all over again. The solution is to package it into a skill once. After that, you say one phrase, and Claude loads the methodology, reads the necessary sources, and produces the result. Three examples from different fields: ### Example 1. Freelance Marketer - `weekly-content-plan` Skill What they do by hand: every Monday, they prepare a week's worth of Telegram posts for three clients. They open the client's brand-voice guide, review recent posts, think up topics based on the product calendar, and draw up a table with hooks and bullets. As a skill, this becomes a five-step instruction: read the client's tone-of-voice file, read the product calendar, check the last 10 posts for repetition, come up with seven topics divided by type (sales-focused, expert, personal), and output a table. The command “let's plan posts for client X for the week” turns an hour of preparation into three minutes of waiting. The marketer checks the result, makes targeted edits, and sends it to the client. ### Example 2. Outsourced Accountant - `monthly-receipts-close` Skill (Author's Example) What they do by hand: for each client in a portfolio, every month they export the bank statement, reconcile it against payments in the accounting system, flag unclassified payments, prepare a preliminary income report, and compare the structure of income with the previous month. The skill is a six-step instruction plus a couple of shell scripts in the `scripts/` folder to parse bank statements. The trigger “close May for client X” prompts Claude to produce a report with anomalies flagged in 4-5 minutes. ### Example 3. Online Program Creator - `welcome-letter-new-participant` Skill What they do by hand: a new participant has paid, and they need to write a welcome email. A good welcome is personal: it takes into account the channel they came from, which product they bought, which cohort they're in, and what materials to send with it. A “hello, we're glad” template doesn't do that. The skill instructs Claude to read `knowledge/audience.md` (who these people are), `knowledge/products/.md` (what they get), and the last three welcome emails (to avoid repetition), then write the email using this structure: hook - product specifics - first three steps - sign-off. Many times faster than doing it by hand. Quality is more consistent because Claude remembers to check three sources, whereas a person in a hurry skips one of them. ### What NOT to Turn into a Skill - **One-off tasks**. If you do it once a year when filing a tax return, just describe it to Claude in chat. A skill pays off after 3+ repetitions. - **Tasks that are too general**. “Help me with marketing” isn't a skill; it's all of marketing. A skill is “a weekly content plan”—a specific action with a specific result. - **Tasks with no repeatable steps**. If the process is different every time, it's not a skill; it's one-off work. ## How Does Skill Creator Write Skills for You?
Key points Skill Creator is a meta-skill from Anthropic, launched with the `/skill-creator` command. It takes you through six steps: draft, test, evaluate, iterate, optimize, package. The result is a ready-to-use SKILL.md tested against 20 trigger-evals (10 should-trigger and 10 should-not-trigger). For a non-programmer, it's the fastest way to write a first working skill—without figuring out YAML or arguing with Claude.
The catch is that it's hard to write a good skill right the first time. A description often ends up too narrow or too broad, misses the phrases users actually use, or conflicts with a neighboring skill. Anthropic addressed this by releasing [skill-creator](https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md), a meta-skill that can create other skills. After installing `anthropics/skills`, tell Claude `/skill-creator` (or just “let's make a skill for the weekly report”) and follow a six-stage workflow: 1. **Draft** - skill-creator asks questions: what the skill should do, which trigger phrases to use, which sources to read, and which steps to follow. The result is the first version of SKILL.md. 2. **Test** - skill-creator generates 20 test prompts: 10 that should trigger the skill and 10 that sound like triggers but should not (near-misses). 3. **Evaluate** - it runs each prompt in a fresh chat and checks whether the skill activated. If it activates where it shouldn't or fails to activate where it should, it flags the result. 4. **Iterate** - it rewrites the description based on failures and runs the tests again. 5. **Optimize** - final polish: checks whether the 1024-character limit is exceeded and whether there are conflicts with existing project skills. 6. **Package** - packages the final SKILL.md and reference files in the correct structure. In practice, it looks like this: you talk to Claude for 15-20 minutes, answer 7-8 clarifying questions, and get a ready, tested skill at the end that activates on the right triggers. Another benefit is that `skill-creator` demonstrates an exemplary style for writing SKILL.md. You can open its own file and see the format, tone, and structure of the steps. It's a case where the tool demonstrates itself—you read it and learn how to write your own. ## Claude Code hooks vs skills: when should you use CLAUDE.md, subagents, or MCP? {#skills-claudemd-subagents-mcp-hooks-which-should-you-use}
Key points Claude Code has five distinct primitives for extending behavior, and they aren't interchangeable. CLAUDE.md is permanent project knowledge. Skills are repeatable workflows activated by triggers. Subagents perform work in parallel in a separate context. MCP connects external systems (APIs, databases). Hooks respond to events automatically. The most common vibe-coder mistake is stuffing everything into CLAUDE.md or trying to make a skill with a hook.
The most common problem in projects I've reviewed is that CLAUDE.md contains project rules, step-by-step publishing instructions, a commit template, and a database description all together. This overloads the context and also fails in practice: Claude doesn't run the instruction “when the user asks to publish” because the model treats all of CLAUDE.md as general context with no explicit triggers. The solution is to assign each item to the right primitive: | What | When to use it | Example | |----|----|----| | **CLAUDE.md** | Knowledge needed ALWAYS | “The project has a set language,” “no long dashes in text,” “the brand is spelled with an ‘o’” | | **Skills** | A repeatable process activated by a trigger | “Publish to production,” “weekly post plan,” “close the client's books for the month” | | **Subagents** | Parallel work or isolating heavy context | “Security audit while I plan a new feature,” “review the codebase in a separate session” | | **MCP** | Connecting an external system | “Get data from the CRM,” “pull tasks from the tracker,” “check the website in a browser” | | **Hooks** | Automatic response to an event | “Run a check after Edit,” “block dangerous commands,” “send a Telegram notification when finished” | In short, the picture boils down to a simple logic: Skills and MCP cover most workflows; Hooks automate routine tasks—code checks, tests, and guardrails. Subagents are needed when context gets heavy. The most common mistake is creating a subagent where a skill should be used. ### Decision Tree When you think, “I need Claude to do X”: 1. **Is this knowledge needed all the time?** For example, “The project has a set language” or “we don't use em-dashes.” → Put it in `CLAUDE.md`. 2. **Is this a triggered procedure that you currently do by hand?** For example, “I write a report every Monday.” → Make a **skill**. 3. **Do you need access to an external system?** For example, the Stripe API or your CRM. → Connect an **MCP server**. 4. **Should Claude Code respond automatically to an event?** For example, run a linter after every Edit. → Write a **hook**. 5. **Is the task heavy, will it consume all the context, and do you need to do something else in parallel?** → Run it in a **subagent**. 90% of an entrepreneur-vibe-coder's tasks fall into categories 1-3. Hooks and subagents are next-level tools for when you've moved beyond “one task at a time.” ### Slash Commands and Skills Are the Same Thing An important change in Claude Code: the old slash-command system (`.claude/commands/`) and skills have effectively merged. The `.claude/commands/deploy.md` file and `.claude/skills/deploy/SKILL.md` both create a `/deploy` command. If the names match, the skill wins. So if you're still using the old slash-command format, move to skills; the syntax is clearer and there are more capabilities. ## 7 Mistakes That Keep a Skill from Working
Key points The most common skill problems aren't Claude bugs; they're mistakes in the skill itself. A description without triggers, an overloaded 2,000-line SKILL.md, two similar skills in conflict, or an attempt to download “everything on the marketplace.” Each of these mistakes breaks either skill activation or how it works.
### 1. A Description Without Triggers: The Skill Doesn't Activate Symptom: you wrote a skill, checked the structure, and everything is valid, but Claude doesn't invoke it for user requests. The cause is almost always the same: a description like “Helper for content writing.” Claude doesn't know which phrases to respond to. Fix: put 3-5 actual user phrases in quotes directly in the description. ### 2. SKILL.md Over 500 Lines: Attention Wanders Anthropic [explicitly recommends](https://code.claude.com/docs/en/skills) keeping the file body within 500 lines. If your instructions are 2,000 lines long, Claude loses focus, follows steps only partially, and gets confused about the order. Fix: move large sections into nearby files—`examples/`, `references/`, `scripts/`—and refer to them from SKILL.md. ### 3. One Skill for “Everything About Content” Instead of Three Small Ones A tempting setup: one big `content` skill with Telegram posts, landing pages, and email all in it. It doesn't work. The skill activates for the wrong requests, mixes up methodologies, and produces an averaged result. Fix: one skill = one repeatable action. If you actually have three routines around “content,” make three skills: `telegram-post`, `landing-section`, `email-broadcast`. ### 4. Skill Without a “When NOT to Use It” Section: Conflicts Symptom: there are two similar skills in the project, and Claude invokes the wrong one. For example, one skill is about an email newsletter, and another is specifically about welcome emails for program participants. Without an explicit “do not activate if the request is about a general mailing list” clause, the welcome-email skill will trigger on any mention of “email.” Fix: spell out negative cases in the description. ### 5. 50 Skills in a Project: Descriptions Get Truncated From the [Claude Code documentation](https://code.claude.com/docs/en/skills):

Skill names are always included, but if there are many skills, their descriptions are cut off to stay within the character limit, which can remove the keywords Claude uses to match your request. Budget - 1% of the model's context window.

— Claude Code Documentation, https://code.claude.com/docs/en/skills
If you downloaded 50 skills collections from a marketplace, some descriptions will be truncated. The keywords you were counting on may disappear. Fix: keep the 10-15 most useful skills in the active project. Keep the rest in an inactive archive outside all discoverable skills directories, for example a separate `skill-archive/` folder in your own materials. Install only the needed skills into the project or personal scope. `~/.claude/skills/` is an installed personal library visible across projects, so moving skills there does not remove them from discovery. ### 6. Skills from Unverified Sources: Security Risk Anthropic warns about this in the [official documentation](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview):

Use skills only from trusted sources: ones you've created yourself or received from Anthropic. A malicious skill may cause Claude to call tools or execute code in ways that differ from the skill's stated purpose.

— Anthropic Agent Skills Overview, https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
A random GitHub repo may contain a skill that leaks your API keys the first time you invoke it. Fix: open SKILL.md and read it yourself before installing. Don't run skills from unfamiliar authors in important projects. ### 7. A Skill Without a Knowledge Folder Produces “Average ChatGPT” The subtlest and most common anti-pattern. A skill is a methodology, but methodology alone means nothing without context. If you write a “make a welcome email” skill, but the project has no file describing the audience and no brand-voice file, Claude will write an average ChatGPT email that's indistinguishable from anyone else's. A skill works at its best only when you've already built the project's [Second Brain](https://ailoot.ai/blog/en/claude-code-second-brain/) according to the principles in the [guide about CLAUDE.md](https://ailoot.ai/blog/en/claude-md-template/). First build the knowledge structure, then create skills that rely on it. Reverse the order, and you'll get routine, average quality instead of personalized work in your style. ## How to Build Your First Skill in 30 Minutes
Key points A step-by-step recipe for building your first working skill: choose one repeatable action, write out the steps, create the folder structure, write the description using the formula, test it on 5-8 prompts, and iterate until it activates where it should. A realistic timeline for a first skill is 30-40 minutes. Each one after that takes 10-15 minutes because the format becomes familiar.
Here's the concrete plan I used to build the first skills in my projects: ### Step 1. Choose One Repeatable Action Open your calendar for the past month. Find a task you've done at least 4-5 times that takes 30-60 minutes each time. Not broad “marketing,” but something specific: “Monday sales report,” “onboarding a new client,” or “updating the price list for a promotion.” The narrower the wording, the simpler the skill and the cleaner the trigger. ### Step 2. Write Out the Process by Hand In a separate file or in a chat with Claude (not for the skill, but as a draft), write out the steps you follow: ``` 1. Open the client database 2. Filter by status "awaiting welcome email" 3. Check which channel the client came from 4. Get the email template for that channel from the "templates" folder 5. Fill in the name, product, and start date 6. Send ``` This isn't a skill yet; it's notes. But without these notes, writing SKILL.md means getting confused from the start. ### Step 3. Create the Folder Structure ```bash mkdir -p .claude/skills/welcome-email-new-client touch .claude/skills/welcome-email-new-client/SKILL.md ``` Or, if you want to use the skill across all your projects, put it in `~/.claude/skills/`. ### Step 4. Write SKILL.md Using the Template Skeleton: ```markdown --- name: welcome-email-new-client description: | Prepares a welcome email for a new client using the template for their acquisition channel. Triggers: "write a welcome email for new client X", "onboard new participant Y", "welcome email for client from channel Z". Do not activate if the request is about a general mailing list or an email campaign—those are other skills. --- # Welcome Email for a New Client ## Steps 1. Read `knowledge/audience/segments.md` - what client segments we have 2. Read `knowledge/templates/welcome/` - templates by channel 3. Identify the client's channel from the request context 4. Insert the client's name, product name, and start date 5. Check the length—it should be no more than 800 characters 6. Output the final email text in a copy-ready format ## Important - Do not use “dear friend” or “hello”—use natural speech - One paragraph, one idea - End with one call to action, not two ``` ### Step 5. Test with 5-8 Prompts Open a blank chat with Claude Code in this project. Try 5 phrases you actually use and 3 similar ones that should not activate the skill: Should trigger: - “Write a welcome email for new client Ivanov” - “Onboard a new participant who bought program X” - “Welcome email for a client from Instagram” Should not trigger: - “Send a promotion email to the whole list” - “Email campaign for the New Year holidays” - “Write a follow-up to a client who hasn't paid” For each one, check whether the skill activated. If it activates in the wrong cases, narrow the description. If it doesn't activate where it should, broaden the trigger phrases. ### Step 6. Iterate on the Description After each failed test, edit only the description—don't touch the instruction body. After 2-3 iterations, the skill starts activating reliably. Save it, commit it, and then use it every day. Final advice: don't try to make your first skill perfect. Make it work. Polish comes after your fifth or tenth skill, when you start seeing patterns in your phrasing and in Claude's responses. Pick one recurring task from your calendar for this week, set aside 30 minutes, and follow the six steps above. Then Claude will work according to your methodology instead of guessing.
### Sources - [Extend Claude with skills - Claude Code Documentation](https://code.claude.com/docs/en/skills) - [Agent Skills overview - Claude Platform Documentation](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) - [Equipping agents for the real world with Agent Skills - Anthropic Engineering Blog](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) - [anthropics/skills - official repository with skill-creator](https://github.com/anthropics/skills) - [Skill Creator SKILL.md - source of the trigger-evals methodology](https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md) - [vercel-labs/agent-skills - design guidelines](https://github.com/vercel-labs/agent-skills) - [Agent Skills open standard - specification](https://agentskills.io)
If you need access to AI models through Ailoot, check out [Ailoot](https://ailoot.ai/). ## Questions about Claude Code Skills in 2026: how to build a skills library for yourself ### Does moving a skill into ~/.claude/skills/ make it inactive? No. That directory is the installed personal scope and makes the skill available across your projects. Keep unused packages in an archive outside all discoverable skill directories, then install only the skills currently needed. ### How do I check whether a description triggers correctly? Try five phrases that should invoke the skill and three similar requests that should not. Use fresh chats, record which skill loaded, and adjust the description when it misses a real request or matches a near-miss. ## Ailoot · The company and its project portfolio Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control. The company and its project portfolio: millions of customers; monthly sales in the billions. Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.