Self Learning
Package procedural know-how so your coding agent stays concise and follows the right workflow freedom for fragile vs flexible tasks.
Overview
Self-learning is a journey-wide agent skill that teaches how to create effective SKILL.md packages—usable whenever a solo builder needs to extend agent capabilities before relying on ad-hoc prompts.
Install
npx skills add https://github.com/philschmid/self-learning-skill --skill self-learningWhat is this skill?
- Teaches modular skill packages: workflows, tool integrations, domain expertise, bundled resources
- Concise-is-key principle: challenge every paragraph for token cost in the shared context window
- Degrees-of-freedom guidance: high freedom for variable tasks, tighter steps for fragile procedures
- Positions skills as onboarding guides that turn a general agent into a domain specialist
- Defaults assume the model is already smart—only add context the agent lacks
Adoption & trust: 3.2k installs on skills.sh; 65 GitHub stars; 1/3 security scanners passed (skills.sh audits).
What problem does it solve?
You want reusable agent expertise but your SKILL.md files are either too verbose for the context window or too loose for fragile multi-step work.
Who is it for?
Indie builders authoring or maintaining custom skills for Claude Code, Cursor, or Codex who care about token budget and procedural clarity.
Skip if: Teams that only need a single API integration with no reusable SKILL.md package, or when a third-party skill already covers the workflow unchanged.
When should I use this skill?
Creating or improving agent skills and need principles for conciseness, structure, and degrees of freedom.
What do I get? / Deliverables
You ship tighter skills with clear workflows, appropriate degrees of freedom, and only the context the agent cannot infer—ready to invoke on real tasks.
- Skill design decisions documented in SKILL.md
- Workflow steps matched to task fragility
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Sketch a research skill workflow before committing to a full competitive-analysis automation.
Draft a SKILL.md for your repo's deploy checklist with tight steps and minimal prose.
Refine a code-review skill so freedom matches how strict your merge gates are.
Trim an overweight skill after production incidents show the agent ignores half the file.
How it compares
Use instead of dumping long domain essays into chat—skills are packaged procedural knowledge, not one-off instructions.
Common Questions / FAQ
Who is self-learning for?
Solo and indie builders who create or curate agent skills and want their SKILL.md files to be concise, structured, and effective across projects.
When should I use self-learning?
Use it while designing skills in Build (agent-tooling), before Ship when standardizing review workflows, and during Operate when updating playbooks—anytime you package domain steps for an agent.
Is self-learning safe to install?
It is documentation-oriented skill guidance; review the Security Audits panel on this Prism page before installing any skill from the open ecosystem.
SKILL.md
READMESKILL.md - Self Learning
# Skill Creator Guide This reference provides guidance for creating effective skills. ## About Skills Skills are modular, self-contained packages that extend the Agent's capabilities by providing specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific domains or tasks—they transform the Agent from a general-purpose agent into a specialized agent equipped with procedural knowledge that no model can fully possess. ### What Skills Provide 1. Specialized workflows - Multi-step procedures for specific domains 2. Tool integrations - Instructions for working with specific file formats or APIs 3. Domain expertise - Company-specific knowledge, schemas, business logic 4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks ## Core Principles ### Concise is Key The context window is a public good. Skills share the context window with everything else the Agent needs: system prompt, conversation history, other Skills' metadata, and the actual user request. **Default assumption: The Agent is already very smart.** Only add context the Agent doesn't already have. Challenge each piece of information: "Does the Agent really need this explanation?" and "Does this paragraph justify its token cost?" Prefer concise examples over verbose explanations. ### Set Appropriate Degrees of Freedom Match the level of specificity to the task's fragility and variability: **High freedom (text-based instructions)**: Use when multiple approaches are valid, decisions depend on context, or heuristics guide the approach. **Medium freedom (pseudocode or scripts with parameters)**: Use when a preferred pattern exists, some variation is acceptable, or configuration affects behavior. **Low freedom (specific scripts, few parameters)**: Use when operations are fragile and error-prone, consistency is critical, or a specific sequence must be followed. Think of the Agent as exploring a path: a narrow bridge with cliffs needs specific guardrails (low freedom), while an open field allows many routes (high freedom). ### Anatomy of a Skill Every skill consists of a required SKILL.md file and optional bundled resources: ``` skill-name/ ├── SKILL.md (required) │ ├── YAML frontmatter metadata (required) │ │ ├── name: (required) │ │ └── description: (required) │ └── Markdown instructions (required) └── Bundled Resources (optional) ├── scripts/ - Executable code (Python/Bash/etc.) ├── references/ - Documentation intended to be loaded into context as needed └── assets/ - Files used in output (templates, icons, fonts, etc.) ``` #### SKILL.md (required) Every SKILL.md consists of: - **Frontmatter** (YAML): Contains `name` and `description` fields. These are the only fields that the Agent reads to determine when the skill gets used, thus it is very important to be clear and comprehensive in describing what the skill is, and when it should be used. - **Body** (Markdown): Instructions and guidance for using the skill. Only loaded AFTER the skill triggers (if at all). #### Bundled Resources (optional) ##### Scripts (`scripts/`) Executable code (Python/Bash/etc.) for tasks that require deterministic reliability or are repeatedly rewritten. - **When to include**: When the same code is being rewritten repeatedly or deterministic reliability is needed - **Example**: `scripts/rotate_pdf.py` for PDF rotation tasks - **Benefits**: Token efficient, deterministic, may be executed without loading into context - **Note**: Scripts may still need to be read by the Agent for patching or environment-specific adjustments ##### References (`references/`) Documentation and reference material intended to be loaded as needed into context to inform the Agent's process and thinking. - **When to include**: For documentation that the Agent should reference while working - **Examples**: `references/finance.md` for financial schemas, `references/mnda.md` for company NDA