Create New Skill

Create a new skill through a guided conversation. Use when a user wants help authoring a skill from scratch, choosing between quick or full guidance, analyzi...

Security Scan

The skill's requirements and runtime instructions are consistent with its stated purpose of interactively authoring new skills; it only fetches documentation or writes files when the user explicitly chooses those options.

Purpose & Capability

Name, description, and instructions align: this is an interactive skill authoring helper. It declares no binaries, env vars, or installs — which is appropriate for an instruction-only skill.

Instruction Scope

Runtime instructions stay within the stated purpose: they guide a step-by-step conversation, optionally fetch documentation (URL/GitHub/local) to generate a workflow, and write SKILL.md/README.md when the user confirms. Fetching docs and writing files are expected behaviours for generating a new skill, but both are gated behind explicit user choices.

Install Mechanism

No install spec and no code files — lowest-risk pattern for this type of skill.

Credentials

The skill requests no environment variables or credentials. It can ask the user to specify constraints such as 'required environment variables' during the guided flow, which is reasonable for a skill-creation tool and only records user-provided values.

Persistence & Privilege

always is false and the skill does not request elevated or cross-skill configuration changes. It will create files in the chosen workspace only after explicit confirmation.

Assessment

This skill is coherent and appears to do what it says, but pay attention before using the optional features: 1) If you tell it to fetch documentation from a URL or GitHub repo, only use trusted sources — remote content can define behavior the agent will incorporate. 2) If you provide a local path, the agent will read files you point it to; avoid exposing directories that contain secrets or credentials. 3) The skill will write SKILL.md and README.md into the chosen workspace when you confirm — review generated files before activating or committing them. 4) If you are uncomfortable with an agent autonomously creating files or fetching external documents, decline those steps or review outputs manually. If you want additional assurance, ask the skill to show the exact generated SKILL.md and README.md before confirming write.

Create Skill

Guide the user through creating a new skill from scratch.

Core Philosophy

A skill should define behavior, not just store documentation.

• A good skill tells the agent when to use it
• A good skill tells the agent what tools to use
• A good skill defines the workflow (in what order)
• A good skill specifies the expected output
• A good skill knows its constraints

Static documentation has little value - the agent can fetch that itself. The skill's value is in encoding the behavior pattern.

Interaction Rules

Input Style

• Always present choices as numbered options (1, 2, 3...).
• Never ask the user to type full words like "quick" or "full".
• Accept the number, the option text, or common abbreviations.

Question Rhythm

• Ask ONE question at a time.
• Wait for the user's answer before asking the next question.
• Never dump multiple questions in a single message.

Communication Style

• Never add self-explanatory filler text.
• Never explain what you are going to do before doing it.
• Keep all prompts as concise as possible.
• Use the same terse style as a real CLI tool.

Workflow

Follow these steps in order:

1. Prompt for mode selection (1 or 2).
2. Prompt for skill purpose (the task it solves).
3. Prompt for trigger conditions (when to use).
4. Prompt for required tools.
5. Prompt for workflow steps.
6. Prompt for expected output.
7. Prompt for constraints.
8. Prompt for install location.
9. Prompt for skill name.
10. (Optional) Fetch and analyze documentation.
11. Show summary.
12. Show preview.
13. Prompt for confirmation.
14. Write files.
15. Show completion with next steps.

Step 1: Mode Selection

Output exactly:

Create a new skill.

1) Quick guidance
2) Full guidance

Choice [1]:

• Default to 1 (Quick) if user just presses Enter.
• If user enters invalid option, re-prompt.

Step 2: Skill Purpose

Ask:

What task does this skill solve?

Accept any natural language answer. Extract the core task.

Examples:

• "Deploy a static blog to GitHub Pages"
• "Convert images to different formats"
• "Query and analyze database schemas"

Step 3: Trigger Conditions

After purpose, ask:

When should the agent use this skill?

1) User explicitly asks for it
2) When user mentions specific keywords
3) When certain conditions are met
4) Not sure / I'll define later

Choice [1]:

If user chooses 2 or 3, ask for the specific trigger details.

Step 4: Required Tools

After trigger, ask:

What tools does this skill need?

1) Built-in tools only
2) External CLI commands
3) API calls
4) Combination of above

Choice [1]:

If user chooses 2 or 3, ask:

• "Which CLI commands? (comma separated)"
• "Which APIs? (describe the service)"

Step 5: Workflow

After tools, ask:

What is the workflow? (describe in order)

1) I'll describe step by step
2) Generate from documentation
3) Use a common pattern

Choice [1]:

If user chooses 1, ask them to describe each step.

If user chooses 2, proceed to Step 10 (fetch documentation).

If user chooses 3, present common patterns:

• "init → configure → run"
• "check prerequisites → setup → execute → verify"
• "collect input → process → output"

Step 6: Expected Output

After workflow, ask:

What should this skill produce?

1) Files (config, code, etc.)
2) Command output
3) API response
4) Combination

Choice [1]:

Ask for specific output format details.

Step 7: Constraints

After output, ask:

Are there any constraints?

1) No constraints
2) OS limitations
3) Required environment variables
4) Configuration requirements
5) I'll specify

Choice [1]:

If user chooses 2-5, gather the constraint details.

Step 8: Install Location

After constraints, ask:

Where to install?

1) Current workspace
2) Shared (all projects)

Choice [1]:

Step 9: Skill Name

After install location, ask:

Skill name (lowercase, hyphenated):

• Propose a name based on the skill purpose if user is unsure.
• Validate format (lowercase, digits, hyphens only).

Step 10: Fetch and Analyze Documentation (Optional)

If user chose to generate workflow from documentation in Step 5:

Where is the documentation?

1) Enter URL
2) GitHub repository
3) Local path

After getting the source:

• Fetch the documentation
• Analyze and extract:
  • Installation commands
  • CLI usage and options
  • Configuration parameters
  • Common workflows
  • Best practices
  • Limitations
• Generate behavior from the analysis:
  • When to trigger
  • What tools to use
  • Step-by-step workflow
  • Expected output format
  • Constraints

Do NOT just copy the documentation. Transform it into behavioral instructions.

Step 11: Summary

After all inputs are collected, show:

Skill: <name>
Task: <purpose>
Triggers: <trigger conditions>
Tools: <tool list>
Workflow:
  1. <step 1>
  2. <step 2>
  ...
Output: <expected output>
Constraints: <constraints>
Location: <workspace|shared>

Continue? [y/n]:

Step 12: Preview

Generate the SKILL.md and show key sections:

• Trigger conditions
• Tools required
• Workflow steps
• Output format

Step 13: Confirmation

Ask:

Write files? [y/n]:

Step 14: Write Files

If confirmed:

• Create the skill directory.
• Write SKILL.md with full behavioral instructions.
• Write README.md.
• If directory exists, stop and ask.

Step 15: Completion

Show:

Created: <path>

To activate:
- Restart the agent, or
- Run: refresh skills

To test:
- "<test prompt>"

Done.

Full Guidance Mode

Full mode adds more detail at each step:

After purpose:

• "Target users? (optional)"
• "What problem does it solve? (detailed)"

After trigger:

• "Exact trigger phrases?"
• "Any negative triggers (when NOT to use)?"

After tools:

• "Specific command versions?"
• "Any setup required?"

After workflow:

• "Error handling?"
• "Rollback steps?"

After output:

• "Output format examples?"
• "Where to save files?"

After constraints:

• "Known issues?"
• "Alternative approaches?"

Writing Rules

SKILL.md Structure

A good SKILL.md should have:

---
name: <skill-name>
description: <brief description>
---

# <Skill Name>

## When To Use

- When user says "..."
- When user wants to "..."

## Tools Required

- tool1: description
- tool2: description

## Workflow

1. Step one - what to do
2. Step two - what to do
3. ...

## Output

- What files/config are produced
- Expected format

## Constraints

- OS limitations
- Prerequisites
- What NOT to do

## Examples

Example usage scenarios

Key Principles

• Write behavior, not documentation
• Be specific about tool usage
• Define clear workflow steps
• Specify exact output format
• Include constraints and boundaries

Generated Skill Quality

The generated skill should be self-contained:

• Agent should know when to use it without asking
• Agent should know what tools to call
• Agent should know the exact workflow
• Agent should know the expected output

If the agent still needs to search the web or figure out the workflow, the skill is not complete.

Language

• Use English by default.
• If user clearly uses another language, switch to that language.