Output format·Developer Tools & Repos

Skill Creator

Name: Skill Creator
Author: zhayujie

Create, install, or update skills in the workspace.

You say

Install this skill Read the source first Free Written by zhayujie · unverified publisher

Context cost: 9.2k tokensestimated from the bundle, loaded when it triggers
Bundle: 4 files · 36.6 kB3 scripts among them — read before you run
Licence: Complete terms in LICENSE.txtfree to use
Last change: —no release on file
Servers it uses: Noneruns standalone

What it does

Create, install, or update skills in the workspace. Use when (1) installing a skill from a URL or remote source, (2) creating a new skill from scratch, (3) updating or restructuring existing skills. Always use this skill for any skill installation or creation task.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Output format

Produces one artefact, exactly shaped.

developer tools

Filed under

Developer Tools & Repos

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md18.8 kB · 430 lines

--- name: skill-creator description: Create, install, or update skills in the workspace. Use when (1) installing a skill from a URL or remote source, (2) creating a new skill from scratch, (3) updating or restructuring existing skills. Always use this skill for any skill installation or creation task. license: Complete terms in LICENSE.txt ---

7# Skill Creator

9This skill provides guidance for creating effective skills using the existing tool system.

11## About Skills

13Skills are modular, self-contained packages that extend the agent's capabilities by providing specialized knowledge, workflows, and tools. They transform a general-purpose agent into a specialized agent equipped with procedural knowledge.

15### What Skills Provide

171. **Specialized workflows** - Multi-step procedures for specific domains

182. **Tool integrations** - Instructions for working with specific file formats or APIs

193. **Domain expertise** - Company-specific knowledge, schemas, business logic

204. **Bundled resources** - Scripts, references, and assets for complex tasks

22### Core Principle

24**Concise is Key**: Only add context the agent doesn't already have. Challenge each piece of information: "Does this justify its token cost?" Prefer concise examples over verbose explanations.

26## Skill Structure

28Every skill consists of a required SKILL.md file and optional bundled resources:

30```

31skill-name/

32├── SKILL.md (required)

33│ ├── YAML frontmatter metadata (required)

34│ │ ├── name: (required)

35│ │ └── description: (required)

36│ └── Markdown instructions (required)

37└── Bundled Resources (optional)

38 ├── scripts/ - Executable code (Python/Bash/etc.)

39 ├── references/ - Documentation intended to be loaded into context as needed

40 └── assets/ - Files used in output (templates, icons, fonts, etc.)

41```

43### SKILL.md Components

45**Frontmatter (YAML)** - Required fields:

47- **name**: Skill name in hyphen-case (e.g., weather-api, pdf-editor)

48- **description**: **CRITICAL** - Primary triggering mechanism

49 - Must clearly describe what the skill does

50 - Must explicitly state when to use it

51 - Include specific trigger scenarios and keywords

52 - All "when to use" info goes here, NOT in body

53 - Example: "PDF document processing with rotation, merging, splitting, and text extraction. Use when user needs to: (1) Rotate PDF pages, (2) Merge multiple PDFs, (3) Split PDF files, (4) Extract text from PDFs."

55**Body (Markdown)** - Loaded after skill triggers:

57- Detailed usage instructions

58- How to call scripts and read references

59- Examples and best practices

60- Use imperative/infinitive form ("Use X to do Y")

62### Bundled Resources

64**scripts/** - When to include:

65- Code is repeatedly rewritten

66- Deterministic execution needed (avoid LLM randomness)

67- Examples: PDF rotation, image processing

68- Must test scripts before including

70**references/** - When to include:

71- **ONLY** when documentation is too large for SKILL.md (>500 lines)

72- Database schemas, complex API specs that agent needs to reference

73- Agent reads these files into context as needed

74- **NOT for**: API reference docs, usage examples, tutorials (put in SKILL.md instead)

75- **Rule of thumb**: If it fits in SKILL.md, don't create a separate reference file

77**assets/** - When to include:

78- Files used in output (not loaded to context)

79- Templates, icons, boilerplate code

80- Copied or modified in final output

82**Important**: Most skills don't need all three. Choose based on actual needs.

84### What NOT to Include

86Do NOT create auxiliary documentation files:

87- README.md - Instructions belong in SKILL.md

88- INSTALLATION_GUIDE.md - Setup info belongs in SKILL.md

89- CHANGELOG.md - Not needed for local skills

90- API_REFERENCE.md - Put API docs directly in SKILL.md

91- USAGE_EXAMPLES.md - Put examples directly in SKILL.md

92- Any other documentation files - Everything goes in SKILL.md unless it's too large

94**Critical Rule**: Only create files that the agent will actually execute (scripts) or that are too large for SKILL.md (references). Documentation, examples, and guides ALL belong in SKILL.md.

96## Installing a Skill

98Install target directory: <workspace>/skills/<name>/ (the <workspace> is from the "Workspace" section).

100### Step 1 — Obtain skill content

101

102| Source | Action |

103|---|---|

104| URL (single file) | Fetch content via curl or web_fetch |

105| URL (zip/archive) | Download and extract to a temp directory |

106| Local file (SKILL.md) | Read directly |

107| Local archive (zip) | Extract to a temp directory |

108

109### Step 2 — Identify and install

110

1111. Locate the SKILL.md (may be at top level or inside a subdirectory)

1122. Extract name from YAML frontmatter

1133. Copy the **entire skill directory** (SKILL.md and all sibling files/folders such as references/, scripts/, assets/, etc.) into <workspace>/skills/<name>/

1144. If an install/setup file exists (e.g. INSTALL.md), follow its instructions — the final result must still end up in <workspace>/skills/<name>/

115

116## Skill Creation Process (from scratch)

117

1181. **Understand** - Clarify use cases with concrete examples

1192. **Plan** - Identify needed scripts, references, assets

1203. **Initialize** - Run init_skill.py to create template

1214. **Edit** - Implement SKILL.md and resources

1225. **Validate** (optional) - Run quick_validate.py to check format

1236. **Iterate** - Improve based on real usage

124

125## Skill Naming

126

127- Use lowercase letters, digits, and hyphens only; normalize user-provided titles to hyphen-case (e.g., "Plan Mode" -> plan-mode).

128- When generating names, generate a name under 64 characters (letters, digits, hyphens).

129- Prefer short, verb-led phrases that describe the action.

130- Namespace by tool when it improves clarity or triggering (e.g., gh-address-comments, linear-address-issue).

131- Name the skill folder exactly after the skill name.

132

133## Step-by-Step Guide

134

135### Step 1: Understanding the Skill with Concrete Examples

136

137Skip this step only when the skill's usage patterns are already clearly understood. It remains valuable even when working with an existing skill.

138

139To create an effective skill, clearly understand concrete examples of how the skill will be used. This understanding can come from either direct user examples or generated examples that are validated with user feedback.

140

141For example, when building an image-editor skill, relevant questions include:

142

143- "What functionality should the image-editor skill support? Editing, rotating, anything else?"

144- "Can you give some examples of how this skill would be used?"

145- "I can imagine users asking for things like 'Remove the red-eye from this image' or 'Rotate this image'. Are there other ways you imagine this skill being used?"

146- "What would a user say that should trigger this skill?"

147

148To avoid overwhelming users, avoid asking too many questions in a single message. Start with the most important questions and follow up as needed for better effectiveness.

149

150Conclude this step when there is a clear sense of the functionality the skill should support.

151

152### Step 2: Planning the Reusable Skill Contents

153

154To turn concrete examples into an effective skill, analyze each example by:

155

1561. Considering how to execute on the example from scratch

1572. Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly

158

159**Planning Checklist**:

160- ✅ **Always needed**: SKILL.md with clear description and usage instructions

161- ✅ **scripts/**: Only if code needs to be executed (not just shown as examples)

162- ❌ **references/**: Rarely needed - only if documentation is >500 lines and can't fit in SKILL.md

163- ✅ **assets/**: Only if files are used in output (templates, boilerplate, etc.)

164

165Example: When building a pdf-editor skill to handle queries like "Help me rotate this PDF," the analysis shows:

166

1671. Rotating a PDF requires re-writing the same code each time

1682. A scripts/rotate_pdf.py script would be helpful to store in the skill

1693. ❌ Don't create references/api-docs.md - put API info in SKILL.md instead

170

171Example: When designing a frontend-webapp-builder skill for queries like "Build me a todo app" or "Build me a dashboard to track my steps," the analysis shows:

172

1731. Writing a frontend webapp requires the same boilerplate HTML/React each time

1742. An assets/hello-world/ template containing the boilerplate HTML/React project files would be helpful to store in the skill

1753. ❌ Don't create references/usage-examples.md - put examples in SKILL.md instead

176

177Example: When building a big-query skill to handle queries like "How many users have logged in today?" the analysis shows:

178

1791. Querying BigQuery requires re-discovering the table schemas and relationships each time

1802. A references/schema.md file documenting the table schemas would be helpful to store in the skill (ONLY because schemas are very large)

1813. ❌ Don't create separate references/query-examples.md - put examples in SKILL.md instead

182

183To establish the skill's contents, analyze each concrete example to create a list of the reusable resources to include: scripts, references, and assets. **Default to putting everything in SKILL.md unless there's a compelling reason to separate it.**

184

185### Step 3: Initialize the Skill

186

187At this point, it is time to actually create the skill.

188

189Skip this step only if the skill being developed already exists, and iteration is needed. In this case, continue to the next step.

190

191When creating a new skill from scratch, always run the init_skill.py script. The script conveniently generates a new template skill directory that automatically includes everything a skill requires, making the skill creation process much more efficient and reliable.

192

193Usage:

194

195```bash

196scripts/init_skill.py <skill-name> --path <output-directory> [--resources scripts,references,assets] [--examples]

197```

198

199Examples:

200

201```bash

202scripts/init_skill.py my-skill --path <workspace>/skills

203scripts/init_skill.py my-skill --path <workspace>/skills --resources scripts,references

204scripts/init_skill.py my-skill --path <workspace>/skills --resources scripts --examples

205```

206

207Where <workspace> is your workspace directory shown in the "Workspace" section of the system prompt.

208

209The script:

210

211- Creates the skill directory at the specified path

212- Generates a SKILL.md template with proper frontmatter and TODO placeholders

213- Optionally creates resource directories based on --resources

214- Optionally adds example files when --examples is set

215

216After initialization, customize the SKILL.md and add resources as needed. If you used --examples, replace or delete placeholder files.

217

218**Important**: Always create skills in workspace skills directory (<workspace>/skills), NOT in project directory. Check the "Workspace" section for the actual workspace path.

219

220### Step 4: Edit the Skill

221

222When editing the (newly-generated or existing) skill, remember that the skill is being created for another instance of the agent to use. Include information that would be beneficial and non-obvious to the agent. Consider what procedural knowledge, domain-specific details, or reusable assets would help another agent instance execute these tasks more effectively.

223

224#### Design Patterns

225

226**Workflow patterns** — For complex tasks, break operations into sequential steps or conditional branches:

227

228```markdown

229# Sequential: list numbered steps with scripts

2301. Analyze the form (run analyze_form.py)

2312. Create field mapping (edit fields.json)

2323. Fill the form (run fill_form.py)

233

234# Conditional: guide through decision points

2351. Determine the modification type:

236 **Creating new content?** → Follow "Creation workflow"

237 **Editing existing content?** → Follow "Editing workflow"

238```

239

240**Output patterns** — When consistent output format matters, provide a template or input/output examples in SKILL.md so the agent can follow the desired style.

241

242#### Start with Reusable Skill Contents

243

244To begin implementation, start with the reusable resources identified above: scripts/, references/, and assets/ files. Note that this step may require user input. For example, when implementing a brand-guidelines skill, the user may need to provide brand assets or templates to store in assets/, or documentation to store in references/.

245

246**Available Base Tools**:

247

248The agent has access to these core tools that you can leverage in your skill:

249- **bash**: Execute shell commands (use for curl, ls, grep, sed, awk, bc for calculations, etc.)

250- **read**: Read file contents

251- **write**: Write files

252- **edit**: Edit files with search/replace

253

254**Minimize Dependencies**:

255- ✅ **Prefer bash + curl** for HTTP API calls (no Python dependencies)

256- ✅ **Use bash tools** (grep, sed, awk) for text processing

257- ✅ **Keep scripts simple** - if bash can do it, no need for Python (document packages/versions if Python is used)

258

259**Important Guidelines**:

260- **scripts/**: Only create scripts that will be executed. Test all scripts before including.

261- **references/**: ONLY create if documentation is too large for SKILL.md (>500 lines). Most skills don't need this.

262- **assets/**: Only include files used in output (templates, icons, etc.)

263- **Default approach**: Put everything in SKILL.md unless there's a specific reason not to.

264

265Added scripts must be tested by actually running them to ensure there are no bugs and that the output matches what is expected. If there are many similar scripts, only a representative sample needs to be tested to ensure confidence that they all work while balancing time to completion.

266

267If you used --examples, delete any placeholder files that are not needed for the skill. Only create resource directories that are actually required.

268

269#### Update SKILL.md

270

271**Writing Guidelines:** Always use imperative/infinitive form.

272

273##### Frontmatter

274

275Write the YAML frontmatter with name, description, and optional metadata:

276

277- name: The skill name

278- description: This is the primary triggering mechanism for your skill, and helps the agent understand when to use the skill.

279 - Include both what the Skill does and specific triggers/contexts for when to use it.

280 - Include all "when to use" information here - Not in the body. The body is only loaded after triggering, so "When to Use This Skill" sections in the body are not helpful to the agent.

281 - Example description for a docx skill: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. Use when the agent needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"

282- metadata: (Optional) Specify requirements and configuration

283 - requires.bins: Required binaries (e.g., ["curl", "jq"])

284 - requires.env: Required environment variables — all must be set (e.g., ["MYAPI_KEY"])

285 - requires.anyEnv: Alternative environment variables — at least one must be set (e.g., ["OPENAI_API_KEY", "LINKAI_API_KEY"])

286 - requires.anyBins: Alternative binaries — at least one must be present

287 - always: Set to true to always load regardless of requirements

288 - emoji: Skill icon (optional)

289 - Do NOT set category — it defaults to skill and is managed by the system

290

291**API Key Requirements**:

292

293If your skill needs a single API key, declare it in requires.env:

294

295```yaml

296---

297name: my-search

298description: Search using MyAPI

299metadata:

300 requires:

301 bins: ["curl"]

302 env: ["MYAPI_KEY"]

303---

304```

305

306If your skill supports multiple API key providers (e.g., OpenAI or LinkAI), use requires.anyEnv:

307

308```yaml

309---

310name: my-vision

311description: Analyze images using Vision API

312metadata:

313 requires:

314 bins: ["curl"]

315 anyEnv: ["OPENAI_API_KEY", "LINKAI_API_KEY"]

316---

317```

318

319**Auto-enable rule**: Skills are automatically enabled when required environment variables are set, and automatically disabled when missing. No manual configuration needed.

320

321##### Body

322

323Write instructions for using the skill and its bundled resources.

324

325**If your skill requires an API key**, include setup instructions in the body:

326

327```markdown

328## Setup

329

330This skill requires an API key from [Service Name].

331

3321. Visit https://service.com to get an API key

3332. Configure it using: env_config(action="set", key="SERVICE_API_KEY", value="your-key")

3343. Or manually add to ~/cow/.env: SERVICE_API_KEY=your-key

3354. Restart the agent for changes to take effect

336

337## Usage

338...

339```

340

341The bash script should check for the key and provide helpful error messages:

342

343```bash

344#!/usr/bin/env bash

345if [ -z "${SERVICE_API_KEY:-}" ]; then

346 echo "Error: SERVICE_API_KEY not set"

347 echo "Please configure your API key first (see SKILL.md)"

348 exit 1

349fi

350

351curl -H "Authorization: Bearer $SERVICE_API_KEY" ...

352```

353

354**Script Path Convention**:

355

356When writing SKILL.md instructions, remember that:

357- Skills are listed in <available_skills> with a <base_dir> path

358- Scripts should be referenced as: <base_dir>/scripts/script_name.sh

359- The AI will see the base_dir and can construct the full path

360

361Example instruction in SKILL.md:

362```markdown

363## Usage

364

365Scripts are in this skill's base directory (shown in skill listing).

366

367bash "<base_dir>/scripts/my_script.sh" <args>

368```

369

370### Step 5: Validate (Optional)

371

372Validate skill format:

373

374```bash

375scripts/quick_validate.py <path/to/skill-folder>

376```

377

378Example:

379

380```bash

381scripts/quick_validate.py <workspace>/skills/weather-api

382```

383

384Validation checks:

385- YAML frontmatter format and required fields

386- Skill naming conventions (hyphen-case, lowercase)

387- Description completeness and quality

388- File organization

389

390**Note**: Validation is optional in COW. Mainly useful for troubleshooting format issues.

391

392### Step 6: Iterate

393

394Improve based on real usage:

395

3961. Use skill on real tasks

3972. Notice struggles or inefficiencies

3983. Identify needed updates to SKILL.md or resources

3994. Implement changes and test again

400

401## Progressive Disclosure

402

403Skills use three-level loading:

404

4051. **Metadata** (name + description) - Always in context (~100 words)

4062. **SKILL.md body** - Loaded when skill triggers (<5k words)

4073. **Resources** - Loaded as needed by agent

408

409**Best practices**:

410- Keep SKILL.md under 500 lines

411- Split complex content into references/ files

412- Reference these files clearly in SKILL.md

413

414**Pattern**: For skills with multiple variants/frameworks:

415- Keep core workflow in SKILL.md

416- Move variant-specific details to separate reference files

417- Agent loads only relevant files

418

419Example:

420```

421cloud-deploy/

422├── SKILL.md (workflow + provider selection)

423└── references/

424 ├── aws.md

425 ├── gcp.md

426 └── azure.md

427```

428

429When user chooses AWS, agent only reads aws.md.

430

In the file

SKILL.md2,716 words

Files4

LicenceComplete terms in LICENSE.txt

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈90

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

9,060

on trigger

The instruction body and 3 supporting files, read only when the skill fires.

4.6%

of a 200k window

Ten skills this size would take about 46% of the window before you open a file.

050k100k150k200k context window

9.2k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

37 other skills in Developer Tools & Repos

What is in the bundle

4 files, 36.6 kB on disk. Mostly text — the instructions the model reads — with 3 scripts in it that your client would run only if the instructions tell it to.

SKILL.md18.8 kB
scripts/init_skill.py10.9 kB
scripts/package_skill.py3.4 kB
scripts/quick_validate.py3.5 kB

What is not in it

A skill installs nothing and depends on nothing: it is a folder your client reads. This one carries 3 scripts beside the text, so the bundle is 4 files you can review in full before installing. The Complete terms in LICENSE.txt licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# Skill Creator · 9.2k tokens when loaded
npx mcprush@latest skill add zhayujie/skill-creator

Writes to .claude/skills/skill-creator/ in the current project. Add --global to put it in your home directory instead, for every project.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Versionnot versioned

Publishedno release date on file

PriceFree

Referencezhayujie/skill-creator

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

No earlier releases have been published to the marketplace.

Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

zhayujie

Publishes on mcprush.

0 servers listed1 skill listednot claimed

Profile

Publisher

Servers0

Claim this skill