SkillAgentSearch skills...

axel-skill

Structure of skill definition files - role, capabilities, enforcement, registry

Install / Use

npx skills add shivamchopra7/claude-skill-directory --skill axel-skill

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

51/100

Supported Platforms

Universal

Tags

Our assessment of axel-skill

axel-skill scores 51/100 on our quality scale, 4323rd of 4,700 Development & Engineering skills we index.

Its SKILL.md is 16 KB long, written without headings with 1 code example: a thorough specification that gives an agent plenty to work with.

It has no GitHub stars yet, so there is no community track record; judge it on its content.

Substance
30/30
Structure
4/20
Description
12/15
Adoption
0/20
Freshness
5/15

Maintenance, license and trust

  • We could not determine when the repository was last updated.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 68/100, with 3 cautions from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-12. Automated pattern scan on 2026-11-12. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

axel-skill compared with similar skills

All 4 of these similar skills score higher than axel-skill; compare them before choosing.

SkillScoreStarsUpdatedFormat
axel-skill (this skill)by shivamchopra7510—SKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install axel-skill?
Run npx skills add shivamchopra7/claude-skill-directory --skill axel-skill. The install tabs above show the steps for each supported agent.
Which AI agents does axel-skill work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is axel-skill safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 68/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is axel-skill still maintained?
We could not determine when the repository was last updated.

name: axel-skill description: Structure of skill definition files - role, capabilities, enforcement, registry type: reference

<document type="reference">

  <enforcement>
    - Read `src` and `ref` attributes from skill references to locate files
    - ${CLAUDE_PLUGIN_ROOT} resolves to plugin installation directory
    - Skill files located in .claude/skills/skill-{name}/ directory
  </enforcement>

  <objective>
    Structure of skill definition files. AXEL Skill is a configuration format that enables AI to specialize in a specific area. Each skill defines a role, capability set, and operating rules for the AI, ensuring consistent and high-quality output.
  </objective>

  <frontmatter>
    <![CDATA[
---
name: skill-frontend             # Skill identifier (with skill- prefix)
description: Frontend dev skill  # Short description, 200 characters
type: skill                      # Always "skill"
allowed-tools:                   # Available tools
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Bash
  - AskUserQuestion
disable-model-invocation: false  # true = manual-only, no auto-invoke (optional)
---
    ]]>
  </frontmatter>

  <templates load="always" mode="context">
    <read src="${CLAUDE_PLUGIN_ROOT}/skills/skill-axel-core/templates/skill/AXEL-Skill-Template-Bootstrap.md"/>
    <axel-tag-structure>
      <![CDATA[
      AXEL-Skill-Tpl.md (Linear) / AXEL-Skill-Staged-Tpl.md (Staged)
      +-- Template Frontmatter
      +-- # AXEL Skill (title)
      +-- {{{xml}}}
      +-- <document type="skill">
      |   +-- <enforcement>
      |   +-- <objective>
      |   +-- <documents name=".." load="always" mode="context">
      |   |   +-- <read src="..."/>
      |   |   +-- <understanding>...</understanding> (required)
      |   +-- <documents name=".." load="on-trigger" mode="context">
      |   |   +-- <read src="..." trigger="..."/>
      |   |   +-- <understanding>...</understanding> (required)
      |   +-- <documents name=".." load="on-demand" mode="context">
      |   |   +-- <read src="..." ask="..."/>
      |   |   +-- <understanding>...</understanding> (required)
      |   +-- <role>
      |   +-- <capabilities>
      |   +-- <templates name=".." load="always|on-demand|on-trigger" mode="context"> (optional)
      |   |   +-- <read src="..." ask="..."/>
      |   |   +-- <understanding>...</understanding> (required)
      |   +-- <examples> (optional)
      |   |   +-- <example name="..." language="...">
      |   +-- <workflows name=".." load="always|on-demand|on-trigger" mode="context">
      |   |   +-- <read src="..." trigger="..."/>
      |   |   +-- <understanding>...</understanding> (required)
      |   +-- <skills name=".." load="on-demand"> (optional)
      |   |   +-- <ref src="..." ask="..."/>
      |   +-- <agents name=".." load="on-demand"> (optional)
      |   |   +-- <ref src="..." ask="..."/>
      |   +-- <triggers> (optional, for staged only)
      |   |   +-- <goto trigger="..." to="stage-id"/>
      |   +-- <execution flow="linear|staged">
      |   |   +-- (linear) text-based step instructions
      |   |   +-- (staged) <stage id="...">
      |   |       +-- <print>...</print>
      |   |       +-- <tasks output="...">...</tasks>
      |   |       +-- <bash run="..."/>
      |   |       +-- <workflow src="..." output="...">
      |   |       |   +-- <param name="..." value="..."/>
      |   |       +-- <call command="/..."/>
      |   |       +-- <ask var="..." prompt="...">
      |   |       |   +-- <goto when="..." to="stage-id"/>
      |   |       +-- <invoke name="Task|Skill" output="..." resumable="true|false">
      |   |       |   +-- <param name="..." value="..."/>
      |   |       +-- <set var="..." from="..."/>
      |   |       +-- <goto when="..." to="stage-id"/>
      |   |       +-- <stop kind="end|error"/>
      +-- </document>
      +-- {{{xml}}}
      ]]>
    </axel-tag-structure>
    <understanding>
      !! MANDATORY: READ → UNDERSTAND → APPLY !!
      - READ the template file first
      - UNDERSTAND the structure and patterns
      - APPLY the template structure EXACTLY
      Reference = HOW to think | Template = HOW to write
    </understanding>
  </templates>

  <context>
    - Used to specialize AI in a specific domain
    - Defines role, capabilities, and operating rules
    - Activated by trigger keywords
    - Ensures consistent and high-quality output
    - Integrates with documents, templates, and workflows
  </context>

  <principle name="skill-structure">
    - role: Defines who the AI is (persona, expertise level)
    - objective: Main goal and purpose of the skill
    - capabilities: What the skill can do (bullet list)
    - documents: Reference documents (load="always" or "on-trigger")
    - templates: Output templates (load="on-trigger")
    - workflows: Step-by-step processes (load="on-trigger")
    - triggers: Stage routing rules (optional, for staged execution)
    - execution: Linear text or staged XML blocks (flow="linear|staged")
  </principle>

  <principle name="staged-execution">
    When to use staged execution (flow="staged"):
    - Complex skills requiring multi-step processing
    - Skills with branching logic based on input
    - Skills that invoke agents or workflows
    - Skills needing user confirmation checkpoints

    When to use linear execution (flow="linear"):
    - Simple guidance-only skills
    - Skills with straightforward single-path logic
    - Skills focused on context provision, not task orchestration

    Stage elements:
    - stage id="...": Define execution stage
    - tasks output="...": Declarative task block
    - print: Output message to user
    - set var="..." from="...": Variable assignment
    - goto when="..." to="...": Conditional jump
    - invoke name="...": Call agent/skill
    - workflow src="...": Execute workflow
    - stop kind="end|error": Terminate execution
  </principle>

  <principle name="trigger-routing">
    Automatic stage routing based on user input triggers.

    Trigger format:
    - Single phrase: trigger="create component"
    - Multiple keywords: trigger="[a11y, accessibility, wcag]"

    Behavior:
    - When skill activates, check user message against triggers
    - If match found, jump directly to target stage
    - If no match, start from "init" stage (default)

    Example:
    <triggers>
      <goto trigger="create component" to="component-create"/>
      <goto trigger="[test, testing]" to="test-stage"/>
    </triggers>
  </principle>

  <principle name="registry-loading">
    - load="always": Always load into context
    - load="on-demand": Load when requested (ask keywords)
    - load="on-trigger": Load when specific triggers match
    - mode="context": Add document content to AI context
    - mode="map": Load as reference map only
  </principle>

  <pattern name="naming-convention">
    <![CDATA[
    Skill Naming (Claude Code Style)

    Two scope levels:

    1. Plugin Level:
       Format: {plugin}:{skill-name}
       Example: axel:skill-axel-expert

    2. User Project Level:
       Format: {project}:{skill-name}
       Example: myproject:skill-frontend

    Structure:
    <skills name="expert-skills" load="on-demand">
      <ref src="axel:skill-axel-expert" ask="axel, dsl, document"/>
      <ref src="axel:skill-axel-researcher" ask="research"/>
    </skills>

    Usage in registries:
    - src attribute uses this naming format
    - Claude Code resolves names to actual skill files
    - Plugin skills: Defined in plugin's skills/{skill-name}/ folder
    - User skills: Defined in project's .claude/skills/{skill-name}/ folder
    ]]>
  </pattern>

  <pattern name="agents-registry">
    <![CDATA[
    Agents registry for autonomous tasks within skills.

    Naming Format (Claude Code Style):

    1. Plugin Level:
       Format: {plugin}:{agent-folder}:{agent-name}
       Example: axel:agent-axel-project-create:agent-axel-project-create

    2. Plugin Skill Level:
       Format: {plugin}:{skill}:agents:{agent-name}
       Example: axel:skill-axel-expert:agents:agent-axel-expert-creator

    3. User Project Level:
       Format: {project}:{agent-folder}:{agent-name}
       Example: myproject:agent-code-reviewer:agent-code-reviewer

    4. User Skill Level:
       Format: {project}:{skill}:agents:{agent-name}
       Example: myproject:skill-frontend:agents:agent-component-generator

    Structure:
    <agents name="expert-agents" load="on-demand">
      <!-- Plugin skill sub-agent -->
      <ref src="axel:skill-axel-expert:agents:agent-axel-expert-creator" ask="create"/>
      <!-- Plugin level agent -->
      <ref src="axel:agent-project-analysis:agent-project-analysis" ask="analyze"/>
    </agents>

    Attributes:
    - name: Registry identifier (e.g., "expert-agents")
    - load: Always "on-demand" for agents
    - src: Claude Code agent naming style reference
    - ask: Keywords that trigger agent loading
    ]]>
  </pattern>

  <decision name="trigger-based-loading" date="2024-12">
    When: Defining document/template/workflow references
    Action: Use triggers attribute for conditional loading
    Example: triggers="[a11y, accessibility]"
    Reason: Optimizes context size by loading only relevant resources
  </decision>

  <decision name="enforcement-placement" date="2024-12">
    When: Creating skill files
    Action: AXEL-Enforcement.md comes from Bootstrap (no direct reference needed)
    Reason: Bootstrap provides core enforcement rules to all documents
  </decision>

  <requirements>
    - Frontmatter must include name (skill-* prefix), description, type: skill
    - Frontmatter must define allowed-tools list
    - Frontmatter may include disable-model-invocation (default: false)
    - Document root must have type="skill"
    - Role must define AI persona and expertise
    - Objective must specify skill purpose
    - Capabilities must be in bullet list format
    - Documents registry should be defined (AXEL-Enforcement comes from Bootstrap)
    - AXEL-Bootstrap.md MUST be loaded FIRST in documents registry with load="always"
    - Execution must specify flow="linear" or flow="staged"
    - Staged execution requires at least "init" and "complete" stages
    - Triggers tag is optional, only valid with flow="staged"
    - Stage ids must be unique within execution block
    - Last stage must end with <stop kind="end|error"/>
  </requirements>

  <implementation name="file-locations">
    <![CDATA[
    .claude/skills/skill-{name}/
    ├── SKILL.md                  # Main skill file (1,500-2,000 words max)
    ├── agents/                   # Skill-specific sub-agents
    │   └── agent-{name}/         # Sub-agent directory
    │       └── AGENT.md          # Sub-agent definition
    ├── references/               # Skill-specific references (2,000-5,000+ words each)
    │   ├── patterns.md           # Detailed patterns and guides
    │   └── advanced.md           # Advanced use cases
    ├── templates/                # Skill-specific templates
    ├── workflows/                # Skill-specific workflows
    ├── examples/                 # Working code examples
    │   ├── basic-example.sh      # Simple example
    │   └── advanced-example.json # Complex example
    └── scripts/                  # Validation/test tools
        ├── validate.sh           # Validation script
        └── test-trigger.sh       # Trigger test script
    ]]>
  </implementation>

  <principle name="progressive-disclosure">
    Content size management for context optimization:
    - Metadata (frontmatter): ~100 words, always in context
    - SKILL.md body: Max 5,000 words (ideal: 1,500-2,000)
    - Bundled resources (references/, examples/): Unlimited, load on-demand
    - Move detailed guides to references/
    - Move code samples to examples/
    - Move validation tools to scripts/
  </principle>

  <principle name="writing-style">
    <![CDATA[
    Imperative Form (MANDATORY):
    - CORRECT: "To create a hook, define the event type"
    - CORRE

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars0
CategoryDevelopment
UpdatedNaNy ago
Forks0

Trust signals

68/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

2 medium1 low
axel-skill — Universal Skill: Install & Safety Check | SkillAgent