Writing Skills Guide

Build a Claude Code skill in 3 minutes. Create a SKILL.md file, define a vault.yaml manifest, and publish.

Let's build your first skill. Not a toy example — a real, useful skill that people will actually install. By the end you will understand what makes a skill effective, how Claude Code uses SKILL.md files, and how to publish it to the marketplace.

What is a skill?

A skill is a prompt file stored in .claude/skills/. When a buyer runs myclaude install @creator/your-skill, that file lands in their Claude Code environment. From that point forward, they can invoke your skill by typing /your-skill-name in any Claude Code session.

Claude Code reads the SKILL.md content and follows the instructions inside it. That means your skill is literally prompt engineering — packaged, versioned, and distributed.

The quality of a skill is entirely determined by the quality of SKILL.md. Good skills are specific, opinionated, and give Claude enough context to perform consistently.

Create your first skill

Let's build a code review skill. Concrete, useful, well-defined.

Scaffold the project

$ myclaude init code-reviewer
$ cd code-reviewer

You now have two files: SKILL.md and vault.yaml. Open them both.

Write SKILL.md

This is the important file. Here is a minimal but effective SKILL.md for a code reviewer:

## When to use this skill
Use when reviewing code for correctness, security vulnerabilities, performance
issues, or style compliance. Works on any language.

## When NOT to use this skill
Do not use for generating new code. Do not use for general debugging help.

## Instructions

You are a systematic code reviewer. When invoked, follow this exact protocol:

1. **Read the full diff or file** before commenting on any line
2. **Security first** — flag any authentication, injection, or data exposure
   issues before anything else
3. **Performance second** — identify O(n²) patterns, unnecessary re-renders,
   or database query problems
4. **Style last** — naming, readability, consistency with existing patterns

For each issue, output:
- Severity: [CRITICAL / HIGH / MEDIUM / LOW]
- Location: file:line
- Issue: one sentence description
- Fix: concrete suggestion or code snippet

If no issues are found, output: "No issues found. Code looks good."

Do not be verbose. Do not explain what good code looks like in general.
Find the actual problems in the actual code.

That is a complete, publishable skill. It is specific enough that Claude will produce consistent output, and opinionated enough that buyers know exactly what they are getting.

SKILL.md anatomy

Every SKILL.md should have three sections. All three matter.

When to use this skill

One to three sentences. Tell Claude the exact trigger condition for this skill. Be specific — vague "use this for anything related to X" instructions produce inconsistent behavior.

Good: "Use when reviewing a Pull Request diff or a specific file for production readiness."

Bad: "Use for code stuff."

When NOT to use this skill

Often as important as the positive case. This section prevents Claude from over-applying the skill to requests that would be better served by something else.

Good: "Do not use for generating new code from scratch. Do not use for explaining concepts — invoke /explain instead."

Bad: (omitting this section entirely)

Instructions

The main event. Write this as a precise briefing to Claude. Include:

• A persona statement if helpful ("You are a senior security engineer...")
• The exact steps to follow in order
• Output format (structure your output like this...)
• Examples when the expected output is non-obvious
• Edge cases Claude should handle

Longer is not better. 200-400 words of precise instruction outperforms 2,000 words of vague guidance. Every sentence in Instructions should constrain Claude's behavior — if a sentence does not change what Claude does, remove it.

Adding to vault.yaml

Open vault.yaml and fill it out:

name: code-reviewer
version: "1.0.0"
category: skill
description: "Systematic code review: security, performance, and style — in that priority order."
author: your-username
license: MIT
price: 0
tags: [code-review, security, productivity]

Keep description under 160 characters. It is the first thing buyers read in search results.

See vault.yaml Specification for every available field including pricing, tags, and configuration options.

Testing locally

Before publishing, test your skill in your own Claude Code session:

$ myclaude install --local .

This installs the skill from your local directory into your .claude/skills/ folder without publishing. Open a Claude Code session and invoke it:

/code-reviewer

Review a few real files. Watch what Claude does. Ask yourself:

• Does Claude follow the protocol you defined?
• Is the output format consistent across different codebases?
• Does the "when NOT to use" section actually prevent misuse?

Iterate on SKILL.md until the output is what you would be proud to sell. Then publish.

Publishing

$ myclaude publish

That is it. The CLI validates vault.yaml, scans the content, and creates your marketplace listing. A successful publish prints your product URL:

Published: myclaude.sh/p/your-username-code-reviewer

Your skill is now installable by anyone:

$ myclaude install @your-username/code-reviewer

What makes a skill worth paying for

Free skills are easy to publish. Paid skills need to earn their price. The difference:

• Specificity — a generic "code reviewer" competes with anything. A "Django REST Framework security auditor" has a defensible niche.
• Consistency — the output format is locked down. Buyers know exactly what they get every time.
• Depth — the instructions encode real expertise. A $15 skill should save buyers at least an hour of work.
• Maintenance — version it. Fix edge cases. Publish updates. Buyers trust creators who ship improvements.

Start free. Get downloads. Learn what users actually do with your skill. Price the v2.

Related pages

• vault.yaml Specification — complete field reference for your manifest
• Publishing Your First Product — the full publish tutorial
• Product Categories — other product types beyond skills