Skill Creator

Create, edit, improve, tidy, review, audit, or restructure OpenClaw AgentSkills and SKILL.md files. Optimized for OpenClaw's architecture: sub-agents, contex...

installs

stars

karma

SkillRank score ↗

8.3/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-06-14

oc-skill-creator provides a systematic framework for designing openclaw agent skills, emphasizing phase 0 analysis, style guides, and sub-agent context injection to move beyond format-only specifications toward coherent output quality.

structure

9.0

trigger phrases

9.0

procedure

8.0

edge cases

7.0

documentation

8.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: skill-creator
description: >
  Create, edit, improve, tidy, review, audit, or restructure OpenClaw AgentSkills and SKILL.md files.
  Optimized for OpenClaw's architecture: sub-agents, context fork, skill auto-loading, and references/.
  Covers the full lifecycle: analyze existing work → extract patterns → design skill → write SKILL.md → test → iterate.
  Keywords: skill, create skill, skill creator, SKILL.md, 스킬, 스킬 만들기, 스킬 생성, 스킬 개선, 스킬 수정, 스킬 검토, 스킬 작성, スキル, スキル作成, スキル生成, スキル作成, 技能创建, 创建技能, 生成技能, 改进技能.
---

# OpenClaw Skill Creator

Create, improve, and maintain OpenClaw AgentSkills. This guide covers the full lifecycle from pattern extraction through testing.

## Why This Skill Exists

OpenClaw skills are not just simple prompt files. Skills designed for OpenClaw's architecture — 3-layer loading (description → body → references), sub-agent context injection, Phase 0 analysis — significantly improve agent quality. This skill systematizes those design principles and provides validated examples across 5 types (pipeline, single-task, tool integration, code generation, document conversion).

### Language Policy

- **SKILL.md body**: Always write in **English** — this ensures the skill works across all language environments
- **references/**: English by default. Localized copies may be provided as `filename.ko.md`, `filename.ja.md`, `filename.zh.md`
- **description Keywords**: Include keywords in all target languages (English, Korean, Japanese, Chinese)
- **Generated skills**: Follow the same policy — English body, multilingual keywords

## Key Strengths

1. **OpenClaw-native patterns** — Optimized for OpenClaw architecture: sub-agent context fork, references/ lazy loading, Phase 0 structural analysis
2. **5 validated types** — examples/ includes actual generated skills and case analyses for each type
3. **Style Guide-centric** — Skills that specify "what to preserve" and "what to compress" determine agent quality
4. **skill-audit integration** — Validate generated skills with skill-audit to get 0-100 scores and improvement recommendations
5. **Bundled skill porting** — Checklist for porting existing Codex-based bundled skills to OpenClaw patterns

## OpenClaw Skill Anatomy

```
skill-name/
├── SKILL.md                          # Required. Frontmatter + instructions.
├── references/                       # Optional. Loaded on demand by the agent.
│   ├── output-format.md              #   Output specifications
│   └── subagent-prompt-templates.md  #   Sub-agent prompt templates
├── scripts/                          # Optional. Executable code (Python/Bash/etc.)
│   ├── extract_epub.py
│   └── extract_pdf.py
├── assets/                           # Optional. Files used in output, not loaded into context.
│   └── template.html
└── examples/                         # Optional. Example files for reference.
```

**DO NOT create:** README.md, CHANGELOG.md, INSTALLATION_GUIDE.md, QUICK_REFERENCE.md, LICENSE, or similar auxiliary documentation.

## Frontmatter (Required)

```yaml
---
name: skill-name
description: >
  What this skill does and when it should trigger.
  Include keywords in multiple languages.
  Keywords: keyword1, keyword2, 키워드1, 키워드2.
---
```

- **`name`**: lowercase, hyphens only. Under 64 chars. Prefer short, verb-led names.
- **`description`**: This is the **primary triggering mechanism**. OpenClaw reads this to decide when to load the skill. Include:
  - What the skill does
  - When to use it (triggers, contexts)
  - Keywords in all relevant languages (localized + English)
  - Do NOT put "when to use" info in the body — it's only loaded AFTER triggering.

## Loading Architecture

OpenClaw loads skills in three layers:

1. **Metadata** (name + description) — Always in context. ~100 words per skill.
2. **SKILL.md body** — Loaded when the skill triggers. Keep under 500 lines.
3. **references/** — Loaded on demand when the agent decides it's needed.

**Implication:** Every word in `description` is always costing tokens. Be concise. Every word in SKILL.md costs tokens when the skill triggers. Keep it lean.

---

## Skill Creation: 5-Step Process

### Step 1: Analyze "Well-Done" Results

Before writing anything, analyze examples of **the agent performing the task well without a skill**.

Ask:
- What structure did the output have?
- What did the agent **preserve** (examples, metaphors, quotes, data)?
- What did the agent **compress** (repetition, verbose explanations)?
- What **judgments** did the agent make (grouping, prioritization, restructuring)?
- Why did it make those judgments?

> **This analysis becomes the Style Guide.** This is the most important step.
> A skill that only specifies format but not style produces dry, mediocre results.

### Step 2: Analyze "Failed" Results (if available)

If sub-agents or previous skill versions produced bad results, identify exactly what went wrong:

| Symptom | Likely Cause |
|---------|-------------|
| Output is dry/bland | Missing style guide — no "what to preserve" rules |
| Flow is disconnected | Chunks processed independently — missing Phase 0 context injection |
| Lots of duplication | Missing merge/restructure instructions |
| Inconsistent style | No style rules in sub-agent prompts |
| Sub-agent ignores instructions | Sub-agent prompt lacks context from Phase 0 |

> **Every failure maps to a specific instruction to add to the skill.**

### Step 3: Write Style Guide First

Write the Style Guide **before** the workflow. The workflow is "what order" — the Style Guide is "how to judge."

```markdown
## Style Guide

### Essence
- What is the core of this task? (e.g., "Summarization is restructuring, not compression.")
- What perspective should the agent take?

### Preservation Criteria (NEVER discard)
- Specific examples with "why"

### Compression Criteria (what to reduce)
- Specific examples with "why"

### Style Rules
- Tone, sentence length, formatting conventions
- Rules specific to this context
```

### Step 4: Structure the Workflow

Build the workflow around the Style Guide:

```markdown
## Workflow

### Phase 0: [Analysis Step] (★ Most Important)
What to analyze before starting, and where that information gets used.

### Phase 1~N: [Execution Steps]
Each step's specific instructions.

### Phase N+1: [Validation Step]
How to verify the output meets quality standards.
```

**Key principles:**
- **Phase 0 first** — analyze the full input before dividing into chunks or delegating
- **Context injection for sub-agents** — sub-agents have NO context from the main session. Phase 0 results must be explicitly injected into sub-agent prompts.
- **Validation step** — check output length, structure, and quality

### Step 5: Split into References (if needed)

If SKILL.md approaches 500 lines, split:

| Content type | Where to put it |
|-------------|----------------|
| Output structure/specifications | `references/output-format.md` |
| Sub-agent prompt templates | `references/subagent-prompt-templates.md` |
| Domain knowledge (APIs, schemas) | `references/domain.md` |
| Examples | `references/examples.md` |

Always link references from SKILL.md with a description of **when to read them**.

---

## Sub-Agent Design Patterns

Sub-agents are the #1 source of skill quality degradation. The root cause is always the same: **the sub-agent lacks context that the main agent has.**

### Pattern A: Context Injection

Always include in sub-agent prompts:
1. **Full context** — "This chunk is part of [overall structure]. It covers [topic]."
2. **Specific preservation list** — "In this chunk, preserve: [metaphor, quote, example]"
3. **Judgment criteria** — 3-4 lines from Style Guide
4. **Output format** — How to format the result

### Pattern B: Template with Fill-in-the-Blanks

Don't copy templates verbatim. Use `[ ]` placeholders filled from Phase 0:

```markdown
Sub-agent prompt template (fill `[ ]` from Phase 0 results):

## Context
[Overall structure from Phase 0]
[This chunk's position in the whole]

## Preserve (this chunk only)
[Specific items from Phase 0]

## Instructions
[Depth/format/style rules]

---
[Chunk text]
---
```

**If Phase 0 didn't produce `[ ]` values, the template can't be filled. The sub-agent becomes a context-free "text compressor." This is why Phase 0 is mandatory.**

### Pattern C: Sequential Pipeline

When multiple depth levels exist (e.g., 1x and 5x), use sequential dependency:

```
depth=1x:  Analyze → Chunk → Summarize → Merge → summary.md
depth=5x:  Analyze → Chunk → Summarize → Merge → summary.md
           → Use summary.md as skeleton → Expand → summary_5x.md
```

**Why sequential?** The simpler output provides structure for the complex one. Starting with the complex version means each chunk is independently summarized, losing overall flow.

### Pattern D: Merge ≠ Concatenate

When merging multiple chunk results:
1. Never just concatenate
2. Restructure according to Phase 0's topic flow
3. Remove duplicates (keep the most detailed version)
4. Derive overall takeaways (not just chunk summaries)

---

## Skill File Organization Rules

### Keep SKILL.md Lean

- **Under 500 lines** — split into references/ if longer
- **Only in SKILL.md**: Workflow phases, Style Guide summary, parameter tables, reference links
- **In references/**: Detailed specs, prompt templates, domain knowledge, examples

### Reference File Best Practices

- **One level deep** — all reference files link directly from SKILL.md, not from other references
- **Table of contents** — for reference files over 100 lines
- **Never duplicate** — information lives in either SKILL.md OR a reference file, never both

### Workspace Skills vs Bundled Skills

| | Workspace (`~/.openclaw/workspace/skills/`) | Bundled (`/app/skills/`) |
|---|---|---|
| Persistence | Survives container restarts | Reset on container restart |
| Scope | User-specific, project-specific | Shared, system-wide |
| When to use | Custom workflows, domain knowledge | Universal tools (weather, discord, etc.) |
| Source of truth | **This directory** for new custom skills | Reference only, don't modify |

**Always create custom skills in workspace. Never modify bundled skills.**

---

## Skill Improvement & Auditing

### Audit Checklist

For any skill, check:

**Triggering**
- [ ] `description` clearly explains when to trigger?
- [ ] Keywords in relevant languages?
- [ ] No "when to use" sections in body (should be in description)?

**Style Guide**
- [ ] "What to preserve" with specific examples?
- [ ] "What to compress" with specific examples?
- [ ] Style rules explicit?

**Workflow**
- [ ] Phase 0 (analysis) comes first?
- [ ] Sub-agent context injection specified?
- [ ] Validation/quality check step exists?

**Sub-agent Integration**
- [ ] Prompt templates have `[ ]` placeholders filled from Phase 0?
- [ ] Clear warning about what happens without context injection?

**File Organization**
- [ ] SKILL.md under 500 lines?
- [ ] Long content split to references/?
- [ ] Each reference file describes when to read it?

### Common Anti-Patterns

| Anti-Pattern | Problem | Fix |
|-------------|---------|-----|
| Format-only, no style | Dry, mediocre output | Add Style Guide |
| Sub-agent without context | Disconnected chunks | Add Phase 0 + context injection |
| Simple concatenation | Duplication, no flow | Add restructure instructions |
| Arbitrary chunk boundaries | Content cut mid-section | "Cut only at section/chapter boundaries" |
| Parallel depth generation | Inconsistent structures | Sequential pipeline (simple → complex) |
| Template used verbatim | Context-free instructions | Fill `[ ]` from Phase 0 results |
| "When to use" in body | Never read (body loads after trigger) | Move to description |

---

## References

- `references/openclaw-vs-codex.md` — Differences from the bundled Codex skill-creator and porting checklist
- `examples/summarize.md` — Validation example: summarize skill (sub-agent pipeline type)
- `examples/changelog.md` — Validation example: changelog skill (doc conversion type)
- `examples/scaffold.md` — Validation example: scaffold skill (code generation type)
- `examples/screenshot-capture.md` — Validation example: screenshot-capture skill (tool integration type)
- `examples/unit-converter.md` — Validation example: unit-converter skill (single-task type)
- `examples/skill-audit.md` — Validation example: skill-audit (meta validation tool)

don't have the plugin yet? install it then click "run inline in claude" again.

restructured original 8-section guide into Implexa's 6-component format (intent, inputs, procedure with 6 explicit phases, decision points, output contract, outcome signal), extracted external connections/setup guidance, made sub-agent context injection decision logic explicit, added audit scoring and iteration loop, preserved all 5 skill types and anti-patterns, clarified when to read references vs body, added common failure modes to decision points.

OpenClaw Skill Creator

Intent

This skill systematizes the design and authoring of OpenClaw AgentSkills. Use it when you need to create a new skill from scratch, improve an existing skill's quality, audit a skill against Implexa standards, or port skills from other frameworks. OpenClaw skills are not simple prompt files. Skills designed for OpenClaw's 3-layer architecture (metadata → body → references), Phase 0 structural analysis, and sub-agent context injection produce significantly higher-quality agent behavior. This skill codifies those patterns and provides validated examples across 5 types.

Inputs

Required

task description: What you want the skill to do. Include example inputs/outputs if available.
well-done examples: 2-3 examples of the agent doing the task well without a skill. These reveal the style guide.
failed examples (optional): If sub-agents or prior attempts failed, show the failure and its symptom (dry output, disconnected flow, duplication, inconsistent style).

External Connections

None required. The skill works entirely in your workspace.

Setup Guidance

Workspace location: Store custom skills in ~/.openclaw/workspace/skills/skill-name/ (never modify /app/skills/).
File structure: Follow the OpenClaw anatomy: SKILL.md (required), references/ (optional), scripts/ (optional), examples/ (optional).

Procedure

Phase 0: Analyze Well-Done Results (Most Important)

Input: 2-3 examples of the agent doing the task well without a skill.

Steps:

Study each example for structural patterns. Ask: what order are sections presented? what grouping logic was used?
Identify what the agent preserved (specific examples, metaphors, quotes, data points, formatting). Note the "why" for each.
Identify what the agent compressed or dropped (repetition, verbose explanations, filler). Note the "why."
Extract judgments the agent made (how it prioritized, grouped, or restructured content). Document the criteria.
Synthesize findings into a Style Guide containing: essence (core task), preservation criteria (with examples), compression criteria (with examples), style rules (tone, sentence length, formatting).

Output: Style Guide document (100-200 words). This is the most important artifact. A skill without a style guide produces dry, mediocre output.

Phase 1: Analyze Failed Results (if available)

Input: Failed outputs or prior skill versions. Symptoms: dry/bland output, disconnected flow, duplication, inconsistent style, sub-agents ignoring instructions.

Steps:

Map each symptom to its root cause using the anti-patterns table (see references/anti-patterns.md).
For each failure, extract the specific instruction needed to fix it.
Flag whether Phase 0 context injection is missing (sub-agents processed chunks independently).
Flag whether a Style Guide was present (if not, output will be mediocre by design).
Flag whether sub-agent prompts had [ ] placeholders for dynamic context (if not, sub-agents were context-free).

Output: Failure analysis document mapping symptom → cause → instruction to add.

Phase 2: Write Frontmatter

Input: Task description, style guide essence.

Steps:

Choose a skill name: lowercase, hyphens only, under 64 chars, verb-led (e.g., "summarize-with-examples", "extract-changelog").
Write description field: 2-3 sentences on what the skill does and when to trigger. Include keywords in English, Korean, Japanese, Chinese (if applicable). Description is the triggering mechanism. Do NOT include "when to use" details (those load only after the skill is triggered).
Wrap in YAML frontmatter with --- delimiters.

Output: SKILL.md file with frontmatter block.

Phase 3: Structure Workflow around Style Guide

Input: Style Guide from Phase 0, failure analysis from Phase 1 (if applicable).

Steps:

Divide workflow into phases: Phase 0 (structural analysis before chunking), Phase 1-N (execution steps), Phase N+1 (validation).
Phase 0 must analyze the full input and extract information that sub-agents need (structure, key preservation items, judgment criteria). This output gets injected into sub-agent prompts.
For each execution phase, write 3-5 specific instructions. Link each instruction to the Style Guide.
For sub-agent phases, design prompt templates with [ ] placeholders. Fill placeholders from Phase 0 results (e.g., [Overall structure from Phase 0], [Specific items to preserve in this chunk]).
Add validation/quality check phase at the end: verify output length, structure, style consistency against Style Guide.

Output: Workflow sections in SKILL.md (Phase 0, Phase 1, Phase 2, etc., with explicit instructions and sub-agent prompt templates).

Phase 4: Split Long Content into References

Input: SKILL.md draft.

Steps:

If SKILL.md exceeds 500 lines, split into references/ files.
Move output specifications to references/output-format.md. Move sub-agent prompt templates to references/subagent-prompt-templates.md. Move domain knowledge (APIs, schemas) to references/domain.md. Move examples to references/examples.md.
In SKILL.md, add links to reference files with a brief note on when to read them (e.g., "See references/subagent-prompt-templates.md when delegating to sub-agents").
Keep SKILL.md under 500 lines: Style Guide summary, workflow phases, parameter tables, reference links.

Output: SKILL.md (under 500 lines) plus reference files in skill-name/references/ directory.

Phase 5: Validate with Audit Checklist

Input: Completed SKILL.md and reference files.

Steps:

Check triggering: does description clearly explain when to trigger? are keywords in relevant languages? is "when to use" info absent from the body (it should be in description)?
Check Style Guide: are "what to preserve" items specific with examples? are "what to compress" items specific with examples? are style rules explicit?
Check workflow: does Phase 0 come first and analyze before chunking? are sub-agent prompts filled with context from Phase 0 (not context-free templates)? does validation step exist?
Check sub-agent design: are prompt templates using [ ] placeholders? are Phase 0 results injected into sub-agent prompts? is there a warning about what happens without context injection?
Check file organization: is SKILL.md under 500 lines? are long content sections split to references/? does each reference file state when to read it?
Run skill-audit tool (if available) to get 0-100 quality score and improvement recommendations.

Output: Audit report. Score of 80+ indicates the skill is ready for use.

Phase 6: Iterate and Test

Input: Audit report, score, improvement recommendations.

Steps:

Address any score-reducing issues: add missing Style Guide details, fix Phase 0 analysis, inject context into sub-agent prompts, restructure workflow phases.
If score remains below 80, repeat Phase 5 with focus on the lowest-scoring component.
Test the skill by running it on sample inputs and comparing output to well-done examples from Phase 0. Output should match the style, preservation, and compression criteria.
If output is dry or disconnected, return to the Style Guide and add more specific preservation/compression examples.

Output: Updated SKILL.md file with score 80+. Tested on sample inputs.

Decision Points

If you're creating a new skill from scratch:

Follow the full 6-phase procedure above.

If you're improving an existing skill:

Start at Phase 1 (analyze failures). If the skill has no Style Guide, backtrack to Phase 0 (analyze well-done results). If Phase 0 context injection is missing, add it in Phase 3.

If you're auditing a skill:

Jump directly to Phase 5. If audit score is below 80, identify which component failed (triggering, Style Guide, workflow structure, sub-agent integration, file organization) and loop back to the corresponding phase above.

If a sub-agent produces disconnected or context-free output:

The sub-agent prompt lacks Phase 0 context. Return to Phase 2 (Phase 0 analysis) and extract the missing information. Fill [ ] placeholders in sub-agent prompts. Re-run the workflow.

If output is dry or mediocre:

The Style Guide is missing or vague. Return to Phase 0 and analyze well-done examples more deeply. Extract specific "what to preserve" and "what to compress" rules with concrete examples. Add those rules to the Style Guide.

If you have fewer than 2-3 well-done examples:

Generate examples by running the task manually or asking the agent to do it without the skill. Use those as your training set for the Style Guide.

If a skill needs to support multiple languages:

Write SKILL.md body in English (ensures compatibility across all language environments). Include keywords in frontmatter for all target languages (Korean, Japanese, Chinese). Optionally provide localized reference files as filename.ko.md, filename.ja.md, etc., but the main workflow always runs in English.

If content exceeds 500 lines:

Always split into references/. Do not keep long content in SKILL.md body.

Output Contract

Success looks like:

Frontmatter: YAML block with name (lowercase, hyphens, under 64 chars), description (2-3 sentences + multilingual keywords, no "when to use" details).
Style Guide section: 100-200 words covering essence, preservation criteria (with examples), compression criteria (with examples), style rules.
Workflow phases: Phase 0 (structural analysis with named outputs), Phase 1-N (execution steps with explicit instructions), Phase N+1 (validation/quality check). Sub-agent prompts with [ ] placeholders filled from Phase 0.
File organization: SKILL.md under 500 lines. Reference files in skill-name/references/ with "when to read" notes in SKILL.md.
Audit score: 80+ when run through skill-audit. All components present: triggering, Style Guide, workflow structure, sub-agent context injection, file organization.
Location: Custom skills in ~/.openclaw/workspace/skills/skill-name/. Bundled skills never modified.

Outcome Signal

The skill worked when:

Triggering works: The agent loads the skill when the task matches the description keywords.
Output matches Style Guide: When you run the skill on sample inputs, the output preserves the items specified in "preservation criteria", compresses what's specified in "compression criteria", and follows the style rules.
Sub-agents produce coherent results: Sub-agent outputs are connected to the overall structure (no disconnected chunks, no duplication) because Phase 0 context was injected.
Quality score is 80+: The skill-audit tool confirms all 6 components are present and well-formed.
SKILL.md is under 500 lines: Content is lean and focused. Long specifications live in references/.
No "when to use" in body: The description frontmatter is the sole trigger mechanism. The body focuses on how to execute.

Reference Files

If your skill needs detailed specifications, link to these files:

references/output-format.md , detailed output structure, examples, edge cases
references/subagent-prompt-templates.md , prompt templates with [ ] placeholders for Phase 0 injection
references/domain.md , domain-specific knowledge, APIs, schemas
references/examples.md , worked examples for each skill type

Read these files only if the skill is complex or involves sub-agent delegation.

Common Anti-Patterns to Avoid

Anti-Pattern	Problem	Fix
Format-only, no Style Guide	Output is dry, mediocre	Add "what to preserve" + "what to compress" with examples
Sub-agent without Phase 0 context	Output disconnected, chunks independent	Phase 0 analysis first, inject results into sub-agent prompts
Template used verbatim (no `[ ]` fill)	Sub-agent is context-free	Fill `[ ]` placeholders from Phase 0 results
Simple concatenation of chunks	Duplication, no flow, no restructure	Add merge/restructure instructions that derive overall takeaways
Parallel depth generation	Inconsistent structure	Sequential pipeline: simple version → complex version uses simple as skeleton
Arbitrary chunk boundaries	Content cut mid-thought	"Cut only at section/chapter/logical boundaries"
"When to use" in body	Never read (loads after trigger)	Move to description frontmatter
SKILL.md over 500 lines	Too much token cost, confusing	Split to references/ (output-format, domain, examples, templates)

File Organization Rules

SKILL.md: Lean, under 500 lines. Contains Style Guide summary, workflow phases, reference links, parameter tables.
references/: One level deep. Each reference file describes when to read it. No duplication between SKILL.md and references/.
scripts/: Python, Bash, or other executable code. Optional.
examples/: Example skill files or validation examples. Optional.
assets/: Non-context files (templates, images, etc.). Optional.

Never create: README.md, CHANGELOG.md, INSTALLATION_GUIDE.md, QUICK_REFERENCE.md, LICENSE, or other auxiliary docs.

Original author: haseo-ai
Source: clawhub
Last updated: OpenClaw v2 standards

Skill Creator

related skills

OpenClaw Skill Creator

Intent

Inputs

Required

External Connections

Setup Guidance

Procedure

Phase 0: Analyze Well-Done Results (Most Important)

Phase 1: Analyze Failed Results (if available)

Phase 2: Write Frontmatter

Phase 3: Structure Workflow around Style Guide

Phase 4: Split Long Content into References

Phase 5: Validate with Audit Checklist

Phase 6: Iterate and Test

Decision Points

Output Contract

Outcome Signal

Reference Files

Common Anti-Patterns to Avoid

File Organization Rules