Skills System
On this page
Overview
Skills are reusable instruction sets that tell Claude Code how to behave in your projects. Create a skill once — like "always use type hints in Python" or "follow our Git branching conventions" — and it automatically applies to every session across your projects.
Creating Skills
Create skills through the Open Poet UI:
- Navigate to the Skills panel in the sidebar.
- Click Create New.
- Fill in the required fields:
| Field | Requirements |
|---|---|
name | Lowercase with hyphens, no spaces (e.g., python-best-practices). Max 64 characters. |
category | One of: coding, testing, deployment, documentation, workflow |
content | Markdown instructions that Claude Code will follow. |
enabled | Whether the skill is active and should be synced to projects. |
Skill Structure
Each skill is stored on disk as a YAML-frontmatter markdown file. When synced to a project, the file is placed at .claude/skills/<name>/SKILL.md:
---
name: python-best-practices
description: Python coding standards and type hint requirements
user-invocable: false
---
# Python Best Practices
## Instructions
- Use type hints for all function parameters and return values
- Follow PEP 8 style guidelines
- Write docstrings for public functions
- Prefer f-strings over .format() or % formatting
- Use pathlib instead of os.path for file operations
The description field in the frontmatter is auto-extracted from the first heading or the first line of the content.
Sync Policies
Each project has a skill_policy setting that determines which skills are synced:
| Policy | Behavior |
|---|---|
| Inherit (default) | The project receives all globally enabled skills. This is the default for new projects. |
| Custom | The project has per-project overrides for which global skills are enabled, plus its own project-specific skills. |
Resolution Order
- If
skill_policyis custom: use the per-project global skill overrides. - If
skill_policyis inherit (empty): use all globally enabled skills. - In both cases, any enabled project-specific skills are added.
- Project skills override global skills with the same name.
Sync Process
Skills are synced to each project's .claude/skills/ directory so Claude Code can read them during sessions:
- Automatic sync — skills are synced when starting a new Claude Code session.
- Manual sync — use the Sync Config button in project settings.
What Happens During Sync
- Active skills are written as markdown files to your project's
.claude/skills/directory. - Old or disabled skills are cleaned up automatically.
- For remote (SSH) projects, files are synced via SFTP.
For remote projects (SSH), the sync process uses SFTP to write files to the remote server.
Project-Specific Skills
In addition to global skills, each project can define its own skills that only apply to that project:
- Created through the project's skill panel or the API.
- Follow the same format as global skills.
- Override global skills if they share the same name.
- Useful for project-specific coding conventions, framework-specific rules, or team workflows.
Skill Management
- Create, edit, delete — manage skills via the UI or through the API endpoints.
- Enable/disable — toggle skills on and off without deleting them.
- Categories — organize skills by type: coding, testing, deployment, documentation, workflow.
- Sort order — drag to reorder skills in the list.
Quick Example
Want Claude Code to always use type hints in Python? Create a skill:
- Go to the Skills panel and click Create New.
- Name it
python-types, set category to coding. - Add your instructions:
# Python Type Hints
## Instructions
- Use type hints for all function parameters and return values
- Use PEP 484 syntax (not comments)
- Prefer built-in generics (list[str]) over typing module (List[str])
- Add type hints when modifying existing functions
This skill will now be synced to all your projects and applied to every Claude Code session automatically.
Best Practices
- Keep skills focused — each skill should address a single concern (e.g., "Go error handling" rather than "all Go rules").
- Use imperative language — write instructions as direct commands ("Use type hints" rather than "Type hints should be used").
- Include concrete examples — show code snippets demonstrating the desired patterns.
- Group related instructions — use markdown headings to organize instructions into logical sections.
- Start general, then specialize — begin with language-level skills, then add framework-specific ones as project skills.