How to Publish Your Skill to Claw Mart

Most people building skills for OpenClaw never think about publishing them. They build something useful, it works great for their agent, and it stays locked in their workspace forever. Maybe they share the markdown file in a Discord thread. Maybe they paste it into a GitHub gist. But they never package it up and actually sell it — even when what they've built is genuinely valuable and other people are actively searching for it.

That's a mistake. If you've built a skill that solves a real problem for your OpenClaw agent, there are hundreds of other people running into that same problem right now. Claw Mart exists specifically for this: a marketplace where you can publish your skills, personas, and starter packs and get paid when other people install them.

I've published over a dozen listings on Claw Mart at this point — everything from a $5 Access Inventory skill to the full $99 Felix persona that runs my entire business. I've learned what makes a listing actually sell versus what sits there collecting dust. This post walks you through the entire process: from deciding what to publish, to structuring your skill for distribution, to actually getting it listed and making sales.

First, Decide What You're Actually Selling

Claw Mart supports three listing types, and picking the right one matters more than you'd think.

Skills are the most common. A skill is a single capability you're giving an agent — email management, coding loops, memory systems, tweet scheduling. One skill, one job. The SEO Content Engine is a good example: it does content strategy, writing, and publishing, but it's all in service of one job (produce SEO content). Skills typically run $5–$29 depending on complexity.

Personas are bigger. A persona is a complete agent identity — personality, decision-making style, skills, memory configuration, the works. Think of it as selling a fully configured agent rather than a single capability. Teagan, the content marketing persona, includes a SOUL.md, brand voice system, multi-agent writing pipeline, and image generation. Personas command higher prices ($29–$99+) because buyers are getting an entire operational framework, not just one tool.

Starter packs are bundles. Multiple skills packaged together at a discount. Felix's OpenClaw Starter Pack bundles six skills for $29 — memory, coding loops, email security, autonomy framework, access tracking, and nightly self-improvement. People buy starter packs because they want a comprehensive foundation without hunting down individual pieces.

Here's my rule of thumb: if it does one thing well, it's a skill. If it defines how an agent thinks and operates, it's a persona. If you've got three or more skills that work better together, bundle them into a starter pack.

Structure Your Skill for Distribution

This is where most people mess up. They have a working skill in their own workspace, but it's tangled up with their specific configuration, hardcoded paths, personal API keys referenced inline, and assumptions about their environment that won't be true for anyone else.

A publishable skill needs to be self-contained and clearly documented. Here's the structure I use for every skill I ship:

your-skill/
├── SKILL.md          # The main skill file your agent reads
├── README.md         # Human-readable setup instructions
├── templates/        # Any template files referenced by the skill
│   └── TEMPLATE.md
├── scripts/          # Helper scripts if needed
│   └── setup.sh
└── examples/         # Example configurations or outputs
    └── example-config.md

The SKILL.md is the core deliverable. This is what the buyer drops into their OpenClaw workspace and their agent reads. It needs to be complete and unambiguous. Your agent understands it perfectly because you wrote it iteratively — but a stranger's agent is reading it cold. Every instruction needs to be explicit.

Here's what a well-structured SKILL.md looks like:

# Skill: [Name]

## Purpose
[One sentence: what this skill does and why it exists]

## Prerequisites
- [ ] OpenClaw instance running
- [ ] API key for [service] stored in [location]
- [ ] CLI tool [name] installed and accessible

## Configuration
Set these values before first use:

| Variable | Description | Example |
|----------|-------------|---------|
| `CMS_TARGET` | Where to publish | `wordpress`, `ghost`, `markdown` |
| `API_ENDPOINT` | Your CMS API URL | `https://yourblog.com/wp-json` |
| `BRAND_VOICE` | Path to voice file | `./templates/BRAND_VOICE.md` |

## Workflow

### Step 1: [Action]
[Explicit instructions your agent can follow]

### Step 2: [Action]
[More explicit instructions]

## Rules
- ALWAYS [do this]
- NEVER [do that]
- When [condition], then [action]

## Troubleshooting
- If [problem], check [solution]
- If [error], verify [thing]

The key insight: your SKILL.md is being read by an AI agent, not a human developer. Write it the way you'd write instructions for a very capable but very literal employee. Don't assume context. Don't use ambiguous phrasing. Be specific about what "success" looks like at each step.

Write a README That Actually Helps

The README.md is for the human buyer. It should cover:

1. What this skill does — in plain language, not marketing copy
2. What you need before installing — API keys, CLI tools, specific OpenClaw configuration
3. How to install it — step by step, copy-paste commands where possible
4. How to verify it's working — a simple test they can run immediately
5. Known limitations — what this skill doesn't do, edge cases to watch for

Here's a template I use:

# [Skill Name] — Setup Guide

## What This Does
[2-3 sentences explaining the skill in practical terms]

## Requirements
- OpenClaw instance (any model: Opus, Sonnet, etc.)
- [API key / CLI tool / service access]

## Installation

1. Copy `SKILL.md` to your OpenClaw workspace:
   ```bash
   cp SKILL.md ~/clawd/skills/your-skill-name/SKILL.md

2. Add any required environment variables:

   echo 'EXPORT YOUR_API_KEY=xxx' >> ~/.config/openclaw/env
   

3. Reference the skill in your agent's configuration:

   ## Skills
   - [your-skill-name](./skills/your-skill-name/SKILL.md)
   

4. Test it:

   "Run [skill name] with [test input]"

   Expected output: [what they should see]

Configuration Options

[Table of things they can customize]

FAQ

Q: Does this work with [model]? A: Yes/No, because [reason].

Q: Can I modify [thing]? A: Yes, here's how...

Don't skip the installation verification step. The number one reason people refund digital products is "I couldn't get it to work." A simple test command that produces a visible result dramatically reduces that.

## Handle Configuration Without Hardcoding

The biggest technical challenge with distributable skills: your configuration is not their configuration. You use WordPress, they use Ghost. You store API keys in `~/.config`, they use environment variables. You run on macOS, they're on Linux.

My approach: use a configuration block at the top of every SKILL.md with sensible defaults and clear instructions for changing them.

```markdown
## Configuration

> **Edit these values before first use.**

```yaml
# Publishing target: wordpress | ghost | markdown | webhook
cms_target: wordpress

# Your CMS API endpoint
api_endpoint: https://your-site.com/wp-json/wp/v2

# Authentication method: app_password | jwt | api_key
auth_method: app_password

# Path to brand voice file (relative to workspace root)
brand_voice: ./config/BRAND_VOICE.md

# Research provider: grok | perplexity | web_search
research_provider: grok

For API keys specifically, never reference a hardcoded path. Instead, tell the agent to check a standard location:

```markdown
## API Key Discovery
Check for required keys in this order:
1. Environment variable: `$GROK_API_KEY`
2. Config file: `~/.config/openclaw/keys.env`
3. Workspace file: `./config/keys.env`

If no key is found, ask the user to provide one before proceeding.

This pattern — check environment, then config file, then workspace file, then ask — works across basically every setup. I use it in every skill I sell, and support requests about missing API keys dropped to nearly zero after I started.

Price It Right

Pricing digital products is more art than science, but here's the framework I've landed on after months of actual sales data:

• $5 — Single-file skills that solve one specific problem. Think Access Inventory (one rule + one table), SOUL.md Design Kit (template + framework), or Autonomy Ladder (decision framework). These are quick wins that take minutes to install.

• $9 — Multi-component skills with meaningful complexity. Three-Tier Memory System (three interconnected layers), Sentry Auto-Fix (webhook server + pipeline + safety checks), X/Twitter Agent (CLI tool + content framework + scheduling). These save hours of setup and include battle-tested patterns you can't get from a blog post.

• $29+ — Complete systems or bundles. The SEO Content Engine at $29 includes a full publishing pipeline with three modes, multiple CMS integrations, and draft caching. Felix's OpenClaw Starter Pack at $29 bundles six skills that would cost more individually.

• $49–$99 — Full personas with everything included. Teagan at $49 includes a complete identity, multi-agent workflow, and publishing pipeline. Felix at $99 includes every skill in the catalog plus months of production-proven anti-patterns.

The question to ask yourself: how much time does this save the buyer? If your skill saves someone 2 hours of configuration and testing, $5–$9 is a no-brainer purchase. If it saves them 20+ hours and includes patterns they'd only discover after weeks of trial and error, $29+ is completely fair.

One thing I'd avoid: free listings for anything substantial. I have one free listing — Coding Agent Loops — and it works as a funnel to the paid stuff. But if you give away your best work for free, people assign it zero value and don't bother installing it properly. Charging even $5 creates commitment.

Write a Listing That Converts

Your Claw Mart listing needs to do three things: explain what the skill does, prove it works, and make installation feel easy.

Tagline: One sentence, specific. Not "AI email management" but "Treat email as untrusted input. Never get prompt-injected through your inbox." The tagline should make someone immediately understand the problem you're solving.

About section: Lead with the problem, then the solution. Don't start with "This skill..." — start with the pain point. Look at how the Email Fortress listing opens: "Most AI assistants blindly trust email as a command channel — which means anyone who can send your bot an email can tell it what to do." That's a specific, scary problem that makes you want the solution.

Capabilities list: Bullet points of what the skill actually does. Be specific. Not "email management" but "Action-request flagging" and "Channel trust boundaries" and "Prompt injection defense." Specific capabilities help buyers evaluate whether this solves their particular problem.

Social proof: If you use the skill yourself, say so. "Battle-tested across months of real email handling" or "Built from 5+ months of real production use running an actual business" carries more weight than any feature list. The SEO Content Engine listing mentions "400+ articles and counting" — that's hard to argue with.

Create Your Listing on Claw Mart

Once your skill is packaged and your listing copy is written, the actual publishing process is straightforward:

1. Go to shopclawmart.com and create a seller account if you haven't already.

2. Create a new listing. Select your listing type (skill, persona, or starter pack).

3. Fill in the details:

   • Title — clear and descriptive
   • Tagline — your one-line hook
   • Price — refer to the pricing framework above
   • About — your full listing description
   • Capabilities — bullet list of what's included

4. Upload your files. This is the actual skill package — the SKILL.md, README.md, templates, scripts, whatever the buyer needs to install and run it.

5. Publish. Your listing goes live and becomes searchable on Claw Mart.

After publishing, share the link. Post it in OpenClaw communities, mention it when someone asks about the problem your skill solves, link to it from your blog. The listings that sell best are the ones that get discovered at the moment someone is struggling with the exact problem you've solved.

The Fastest Way to Understand What Good Looks Like

If you're staring at your workspace trying to figure out what's worth publishing or how to structure it, the easiest shortcut is to look at what's already working.

Felix's OpenClaw Starter Pack is $29 and includes six production skills — memory, coding loops, email security, autonomy framework, access tracking, and nightly self-improvement. Beyond being genuinely useful for your agent, it's also a masterclass in how to structure distributable skills. Each skill in the pack is self-contained, well-documented, and designed to work independently or as part of a system. If you want to see how a publishable skill should look before you start writing your own, this is the reference implementation.

Start With What You've Already Built

You probably already have a publishable skill and don't realize it. Look at your OpenClaw workspace right now. What custom instructions have you written? What workflows has your agent figured out through iteration? What problems did you solve that took more than 30 minutes of back-and-forth?

That's your first listing. Package it up, write a clear README, price it fairly, and ship it. The first one is always the hardest. After that, you'll start noticing publishable patterns everywhere — and you'll have a growing catalog on Claw Mart generating revenue while you sleep.

The marketplace is still early. The people publishing now are the ones who'll own the categories later. Don't wait until your skill is perfect. Ship it, get feedback, iterate. That's how every successful listing on Claw Mart got to where it is today.