OpenClaw Skill Development

Overview

In OpenClaw, there are three ways to extend the agent, and choosing the right one matters:

A Skill is just a Markdown file (plus optional scripts/references) that the agent loads on demand and reads to learn when and how to do something. No compiler, no plugin API — which is exactly why Skills scale: they can be written by the agent itself. This project documents the real mechanics and ships a working example.

SKILL.md anatomy

A Skill is a self-contained directory whose entry point is SKILL.md — YAML frontmatter plus Markdown body:

---
name: daily-briefing
description: "Generate a structured daily work briefing from Git activity and manual input.
  Use when (1) user says 'daily briefing'; (2) user asks to summarize today's work;
  (3) user shares work items for formatting."
metadata: { "openclaw": { "emoji": "📋", "requires": { "bins": ["git"] },
  "install": [{ "type": "brew", "package": "git" }] } }
---

## Trigger
- user says "日报" / "daily briefing"
- user shares work items

## Process
1. if no items given, run `{baseDir}/scripts/collect-git-activity.sh` to gather today's commits
2. classify into ✅ done / ⚠️ blocked / 📅 tomorrow
3. format with the template below

## Rules
- use the exact template — no extra sections
- do NOT add a summary or commentary at the end

Key fields that actually matter:

• description is the routing signal — capped around 250 tokens, and it must spell out when to invoke the skill ("Use when (1)… (2)… (3)…"). This is what the agent matches against, so it is the highest-leverage field.
• metadata.openclaw.requires declares dependencies (bins, env, config) so the harness can check the environment before running.
• metadata.openclaw.install lists how to install missing binaries (brew / node / go / uv / download).

How Skills load

The harness discovers Skills from a layered set of locations (workspace-local first, then user-level, then the ~50 skills bundled with OpenClaw), with managed skills installed via clawhub install landing in ~/.openclaw/skills/. Because the loader watches these directories, dropping a new SKILL.md in makes the skill available within a couple hundred milliseconds — no restart. Skills are not free, though: they live in the system prompt, so each one costs tokens, and keeping descriptions tight is a real budget concern.

The worked example — Daily Briefing

The concrete deliverable is a complete Daily Briefing skill, built end to end:

• SKILL.md — trigger, process, a fixed output template (date + ✅/⚠️/📅 sections), and explicit Rules that stop the model from adding chatty commentary.
• scripts/collect-git-activity.sh — a real Bash script that verifies it is in a git repo, collects today's commits (git log --since="$TODAY 00:00" --oneline --no-merges), counts them, and prints a clean activity block the agent folds into the briefing.
• references/ — a report-format guide the SKILL.md links to instead of inlining everything (keeping the always-loaded part small).

Orchestrating with Lobster

For multi-step automation, the course introduces Lobster — OpenClaw's structured shell/workflow language (YAML/JSON), more reliable than free-form agent instructions and more structured than raw Bash. The example pipeline chains four steps with a human-approval gate:

name: news-briefing
steps:
  - id: search
    command: "bash scripts/tavily-search.sh 'AI Agent 2026'"
  - id: summarize
    command: "bash scripts/deepseek-summarize.sh"
    stdin: "$search.stdout"
  - id: preview
    command: "bash scripts/format-preview.sh"
    stdin: "$summarize.stdout"
    approval: "required"            # pause for human approval
  - id: push
    command: "bash scripts/feishu-push.sh"
    stdin: "$summarize.stdout"
    condition: "$preview.approved"  # only runs if approved

Run with lobster run --mode tool; it pauses at the approval step and returns a resume token, then lobster resume --token … --approve yes continues and pushes the briefing to Feishu.

Honest scope

The source material is course content (slides/handouts), not a shipped code repo — so this project is a faithful study of the OpenClaw Skill model plus the worked Daily Briefing skill and Lobster pipeline built from it. That framing is the point: the value is understanding the mechanism (SKILL.md routing, the loading model, token cost, Lobster orchestration) well enough to author skills correctly, not a fictional CLI tool.

What this project signals

• You understand the OpenClaw / Agent-Skills model — SKILL.md vs plugin vs channel, frontmatter routing, the layered loading model, and the system-prompt token budget.
• You can author a real skill end to end: SKILL.md with tight triggers + a supporting Bash script + references.
• You can reach for structured orchestration (Lobster) with human-approval gates when free-form agent steps aren't reliable enough.