OpenClaw Skills Explained: Installing Community Skills and Writing Your Own

What Skills Actually Are

Without skills, OpenClaw is a very polite chatbot. With skills, it's an assistant that reads your calendar, reviews code, creates Jira tickets, and sends Slack messages.

The difference comes down to one file: `SKILL.md`.

A skill in OpenClaw isn't a plugin in the classical sense. There's no binary installation, no npm package manager, no version conflicts. A skill is a Markdown file that tells the agent:

1. What this skill can do (and when to use it)

2. Which scripts or tools it can call

3. How to interpret the output

That's it. The agent reads the SKILL.md, understands the context, and knows what it can use and when.

In our 6-agent setup, we currently use nine skills — four from the community, five written ourselves. This post explains how both work.

---

Installing Skills: Community Skills from Clawhub

The fastest source for ready-made skills is [clawhub.com](https://clawhub.com) — the community platform for OpenClaw skills. There you'll find skills for:

Step 1: Find the Skills Directory

OpenClaw loads skills from a configured directory. By default:

```bash

# Bundled skills (shipped with OpenClaw)

~/.npm-global/lib/node_modules/openclaw/skills/

# User skills (your own and community skills)

~/.openclaw/workspace/skills/

# or

~/.agents/skills/

```

Check which directory your agent loads:

```bash

openclaw config show | grep skills

```

Step 2: Download the Community Skill

Every Clawhub skill has a GitHub repository. Installation:

```bash

# Create skills directory if it doesn't exist

mkdir -p ~/.openclaw/workspace/skills

# Clone the skill (example: ClickUp skill)

git clone https://github.com/clawhub/skill-clickup ~/.openclaw/workspace/skills/clickup

# Or: just copy the SKILL.md directory

cp -r /path/to/downloaded-skill ~/.openclaw/workspace/skills/clickup

```

Step 3: Check the Configuration

Most skills need an API key or token. The SKILL.md explains which environment variables are required:

```bash

cat ~/.openclaw/workspace/skills/clickup/SKILL.md

# → shows: requires CLICKUP_API_TOKEN as env variable

```

Add the token to your .env file:

```bash

echo 'CLICKUP_API_TOKEN=pk_...' >> ~/.openclaw/workspace/.env

```

Step 4: Restart the Gateway

```bash

openclaw gateway restart

```

From now on, the agent knows the skill. At the next startup, it reads the SKILL.md and knows: "When I need to interact with ClickUp, use this skill."

---

Which Skills We Use in Our Setup

For each agent, we selectively activate skills — following the principle of least privilege (no agent has access to everything):

Sam (team lead):

Peter (coding):

Maya (marketing):

Alex (everyday tasks):

Iris (research):

Atlas (CEO assistant):

---

Writing Your Own Skill: A Complete Example

The best thing about OpenClaw skills: you don't need programming experience to write a simple skill. You need a SKILL.md and optionally a shell script.

Here's a real skill we wrote for our setup: Server Health Check.

Step 1: Create the Directory

```bash

mkdir -p ~/.openclaw/workspace/skills/server-health

```

Step 2: Write the Script

```bash

cat > ~/.openclaw/workspace/skills/server-health/check.sh << 'EOF'

#!/bin/bash

# Returns server health data as JSON

echo "{"

echo " \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","

echo " \"uptime\": \"$(uptime -p)\","

echo " \"load\": \"$(cat /proc/loadavg | awk '{print $1, $2, $3}')\","

echo " \"memory\": {"

free -m | awk 'NR==2{printf " \"total\": %s, \"used\": %s, \"free\": %s", $2, $3, $4}'

echo ""

echo " },"

echo " \"disk\": {"

df -h / | awk 'NR==2{printf " \"total\": \"%s\", \"used\": \"%s\", \"available\": \"%s\", \"percent\": \"%s\"", $2, $3, $4, $5}'

echo ""

echo " },"

echo " \"docker_containers\": $(docker ps --format json | wc -l)"

echo "}"

EOF

chmod +x ~/.openclaw/workspace/skills/server-health/check.sh

```

Step 3: Write the SKILL.md

This is the heart of the skill. The SKILL.md explains to the agent in natural language what the skill does and how to use it.

```markdown

# Server Health Check Skill

When to Use

Use this skill when:

Do NOT use this skill for:

How to Use

Run the script:

```bash

bash ~/.openclaw/workspace/skills/server-health/check.sh

```

The script returns JSON with:

Interpretation

```

Step 4: Test It

Send a message to your agent:

"Can you check the server status?"

The agent reads the SKILL.md, recognizes it should call the check.sh script, executes it, and interprets the JSON output into a readable response.

Expected response:

"Server is healthy. Uptime: 14 days.

CPU load: 0.8 (normal).

RAM: 3.1 GB of 8 GB used (39%).

Disk: 42% used, 22 GB free.

All 6 Docker containers running."

---

Advanced Skill: With API Calls

For skills that call external APIs, the pattern looks like this:

```bash

# skills/clickup-daily/report.sh

#!/bin/bash

# Fetches all tasks due today

API_TOKEN="${CLICKUP_API_TOKEN}"

TEAM_ID="${CLICKUP_TEAM_ID}"

TODAY=$(date +%s000) # Unix timestamp in ms

curl -s "https://api.clickup.com/api/v2/team/${TEAM_ID}/task" -H "Authorization: ${API_TOKEN}" -G --data-urlencode "due_date_lte=${TODAY}" --data-urlencode "include_closed=false" | python3 -c "

import json, sys

data = json.load(sys.stdin)

tasks = data.get('tasks', [])

print(f'Due today: {len(tasks)} tasks')

for t in tasks[:10]:

print(f'- [{t["status"]["status"]}] {t["name"]} (ID: {t["id"]})')

"

```

The SKILL.md then explains which environment variables must be set (`CLICKUP_API_TOKEN`, `CLICKUP_TEAM_ID`) and when the agent should call this script.

---

Skills vs. Direct Tool Use: When Which?

A common question: "Should I write a skill or just give the agent the API documentation directly?"

Write a skill when:

Use direct tools when:

In practice: use bundled OpenClaw tools for standard tasks, custom skills for business-specific workflows.

---

Skill Structure for Clarity

A proven directory structure for skills with multiple scripts:

```

skills/clickup/

├── SKILL.md ← Main instruction file

├── scripts/

│ ├── list_tasks.sh ← List tasks

│ ├── create_task.sh ← Create a task

│ └── update_status.sh ← Change status

└── README.md ← Optional human-readable docs

```

The SKILL.md references the scripts:

```markdown

List Tasks

```bash

bash ~/.openclaw/workspace/skills/clickup/scripts/list_tasks.sh --list-id LIST_ID

```

Create a Task

```bash

bash ~/.openclaw/workspace/skills/clickup/scripts/create_task.sh \

--list LIST_ID \

--name "Task Name" \

--priority 2

```

```

The agent reads all of this and knows: "When I need to create ClickUp tasks, I use create_task.sh with these parameters."

---

Common Mistakes When Writing Skills

Instructions that are too vague: "Use this skill for ClickUp stuff" is not helpful. Be precise: "Use this skill when the user wants to create a task, change a status, or query tasks due today."

Missing error handling: Scripts should always return an exit code and write errors to stderr. The agent can handle errors — but only if it sees them.

SKILL.md files that are too large: If the SKILL.md has 500+ lines, it fills the context window. Focus on the essentials; detailed documentation goes in a separate README.md.

Scripts without executable permission:

```bash

chmod +x skills/my-skill/script.sh

```

Forgetting this: the agent sees "Permission denied" and doesn't know what to do.

---

The Result: What Skills Mean for Our Setup

Before skills, the agent had to improvise with every task: "How do I create a ClickUp task again? What API format does it expect?" This led to errors, hallucinations, and inconsistent results.

With skills: the agent reads the SKILL.md, knows the steps, runs the script, interprets the result. Consistent, fast, reliable.

Effort for a simple skill: 30–60 minutes. Value: every hour the agent handles that task on its own afterward.

The skills we use in our 6-agent setup — including the complete SKILL.md files and scripts for ClickUp, Outlook, GitHub, and Discord — are documented in the OpenClaw Setup Playbook.

Fully available in German too. 🇩🇪