Skills & AutomationSkills & Automation

🎯 AI That Learns Without Limits vs AI That Only Answers Questions

Picture two AIs. The first answers questions well, but that is all it does. The second learns new work all the time, uses complicated tools, connects to all sorts of APIs, and carries out complex jobs methodically — that is the difference between a traditional chatbot and an OpenClaw agent with a skill system.

The skill system is a game changer, because it turns an AI agent from something that "can talk" into something that genuinely "can work". Research reports, presentations, email management, even controlling a smart home — all of it becomes possible because the agent can "learn" new skills and combine them intelligently.

🏗️ Skill Architecture — The Structure That Makes an Agent Smart

The heart of the OpenClaw skill system is the SKILL.md file, which works like a manual the agent can read and understand. When a user sends a request, OpenClaw looks at the <available_skills> list to find a suitable skill, then loads it and follows the instructions in that SKILL.md.

🔍 Agent Skill Discovery Process

The process runs like this:

1. User sends a request: "create a presentation about AI"
2. OpenClaw scan available_skills looking for matches
3. Finds a skill whose description matches presentation work
4. Loads that skill's SKILL.md with the read tool
5. Follows the instructions in the skill to finish the job

📁 Skill Directory Structure

A typical skill's directory structure looks like this:

my-awesome-skill/
├── SKILL.md          # the main manual for the agent
├── scripts/
│   ├── main.py       # script that does the main work
│   └── helpers.js    # utility functions
├── templates/
│   └── output.html   # template for the output
├── examples/
│   └── demo.json     # usage example
└── assets/
    └── icon.png      # the icon and other files

🌐 ClawHub Marketplace — The Skills Hub for Everyone

ClawHub (clawhub.com) is the marketplace for OpenClaw skills, where searching, installing, updating and publishing a skill are all straightforward — whether you are a user who wants a skill ready to run, or a developer who wants to share one you have built.

🚀 Installing and Managing Skills

Working with ClawHub from the CLI goes like this:

# search for the skill you want
clawhub search "research"

# install a skill from ClawHub
clawhub install academic-deep-research

# update a skill you already have
clawhub update academic-deep-research

# install a specific version
clawhub install [email protected]

# list the skills you have installed
clawhub list --installed

📦 Version Management

ClawHub supports semantic versioning, so versions can be managed systematically:

# see the available versions
clawhub versions academic-deep-research

# install the latest version
clawhub install academic-deep-research@latest

# roll back to an older version
clawhub install [email protected]

# update every skill at once
clawhub update --all

🔧 Publishing Your Skills

If you have built a new skill and want to share it with the community, you can publish it like this:

# prepare the skill directory
cd my-custom-skill/

# check the structure and the metadata
clawhub validate

# publish a new skill
clawhub publish

# update a skill you have already published
clawhub publish --update

🔬 Anatomy of SKILL.md — Dissecting the Structure an Agent Understands

The SKILL.md file is the essential heart of every skill, because it defines how the agent works, when it works, and with which tools. Let us look at each important part:

📋 Basic Metadata

# Frontend Design Ultimate

Build distinctive, production-grade static sites with React, Tailwind CSS, and shadcn/ui — no mockups needed. Generates bold, memorable designs from plain text requirements with anti-AI-slop aesthetics, mobile-first responsive patterns, and single-file bundling.

**Use when:** building landing pages, marketing sites, portfolios, dashboards, or any static web UI.

**NOT for:** complex backend systems, real-time features, or database-heavy applications.

🎯 Trigger Conditions

This part tells the agent when it should reach for this skill:

Use when:
- User asks to "create a landing page" or "build a website"
- Request mentions "React", "Tailwind", or "shadcn/ui"
- Need to create marketing sites or portfolios
- Building dashboards or admin interfaces

NOT for:
- Backend development or API creation
- Complex state management applications
- Apps requiring real-time features

📝 Detailed Instructions

The instructions the agent will follow, step by step:

## Workflow

1. **Gather Requirements**
   - Ask for site purpose, target audience, key content
   - Identify required pages and features
   - Determine preferred styling direction

2. **Design Strategy**
   - Generate bold, memorable design concept
   - Plan responsive layout structure
   - Select appropriate shadcn/ui components

3. **Implementation**
   - Create React component structure
   - Implement Tailwind styling with custom theme
   - Add interactive elements and animations

4. **Optimization**
   - Ensure mobile-first responsive design
   - Optimize performance and accessibility
   - Test across different devices

🛠️ Scripts and References

Links to the scripts and the reference documents it needs:

## Scripts

- `scripts/component-generator.js` - Generate React components
- `scripts/tailwind-config.js` - Custom Tailwind configuration
- `scripts/build-optimizer.js` - Bundle optimization

## References

- [shadcn/ui Documentation](https://ui.shadcn.com/)
- [Tailwind CSS Guide](https://tailwindcss.com/docs)
- [React Best Practices](https://react.dev/learn)

📁 Assets and Templates

The supporting files the skill needs in order to run:

## Assets

- `templates/landing-page.jsx` - Landing page template
- `templates/dashboard.jsx` - Dashboard layout template
- `assets/default-theme.css` - Default theme configuration
- `examples/portfolio-demo/` - Complete portfolio example

⚡ Building a Custom Skill — From Idea to Working Skill

OpenClaw makes building a new skill straightforward through the skill-creator workflow, which generates the basic scaffold, lays out the structure, and helps you test the skill systematically.

🎨 Step-by-Step Creation Process

1. Use the Skill Creator

# invoke skill-creator
From OpenClaw: "create a custom skill for managing a todo list"

# skill-creator will produce:
- SKILL.md template
- scripts/ directory structure
- examples/ and templates/
- basic metadata and configuration

2. Define the Skill Metadata

# example SKILL.md for a todo skill
# Todo Manager

Manage task lists with priorities, due dates, and categories. Supports adding, completing, filtering, and reporting on tasks.

**Use when:** user wants to create, manage, or organize todo items, task lists, or project tasks.

**NOT for:** complex project management, calendar scheduling, or collaborative planning.

3. Write the Implementation Scripts

// scripts/todo-manager.js
const TodoManager = {
    addTask(title, priority = 'medium', dueDate = null) {
        const task = {
            id: Date.now(),
            title,
            priority,
            dueDate,
            completed: false,
            createdAt: new Date()
        };
        this.saveTask(task);
        return task;
    },

    completeTask(id) {
        const task = this.getTask(id);
        if (task) {
            task.completed = true;
            task.completedAt = new Date();
            this.saveTask(task);
        }
        return task;
    }
};

4. Create Templates and Examples

# templates/task-report.md
# Task Report - {{ date }}

## Completed Tasks ({{ completedCount }})
{{#completedTasks}}
- ✅ {{title}} ({{priority}})
{{/completedTasks}}

## Pending Tasks ({{ pendingCount }})
{{#pendingTasks}}
- ⏳ {{title}} ({{priority}}) - Due: {{dueDate}}
{{/pendingTasks}}

5. Testing and Validation

# test the skill in development mode
openclaw test-skill ./my-todo-skill

# check the syntax and the structure
openclaw validate-skill ./my-todo-skill

# try it for real in a sandbox
openclaw run-skill my-todo-skill "create a new task: write the AI report"

6. Packaging and Publishing

# build the .skill package
openclaw package-skill ./my-todo-skill

# publish it to ClawHub
clawhub publish ./my-todo-skill

🚀 Real-World Skill Examples — Capabilities That Actually Work

Here are skills that genuinely work and are in use across the OpenClaw ecosystem today, along with the range of jobs they are used for:

💼 Integration Examples

These skills can work together. For example:

# Example workflow: research, then present
1. Use literature-search to find papers on the topic
2. Use academic-deep-research to analyze and summarize them
3. Use PptxGenJS to build a presentation from what came back
4. Use blog publishing to write an article for the website

🔒 SkillGuard Security — Defending Against Untrusted Skills

Once skills can reach into the system and run code, security matters all the more. SkillGuard is a security scanner that inspects a skill before it is installed, to head off a range of threats.

🕵️ Security Threat Detection

SkillGuard looks for several kinds of security risk:

🧪 Test Fixtures and Validation

SkillGuard ships with a set of test fixtures for exercising its detection:

# scan a skill before installing it
skillguard scan suspicious-skill.skill

# result
⚠️  POTENTIAL THREATS DETECTED:
- Credential theft pattern in scripts/helper.py
- Obfuscated code execution in templates/config.js
- External network access without declaration

# examples of the threat patterns it can catch
- String concatenation used to hide a dangerous command
- Base64 encoded malicious payloads
- Subtle prompt injection attempts
- Time-based execution bombs
- Unicode manipulation for evasion

🔍 Scanning Workflow

# Automatic scanning when installing from ClawHub
clawhub install unknown-skill
# → SkillGuard scans it automatically

# Manual scanning for local skills
skillguard scan ./my-skill-directory

# Detailed report
skillguard scan --verbose --report-file security-report.json

# see the test coverage
skillguard test-fixtures

🔄 ClawFlows — Powerful Multi-Skill Pipelines

ClawFlows is the system that lets us wire several skills together into a complex workflow, complete with logic, conditions, and data passed from one step to the next.

🎯 Workflow Composition

Building a ClawFlow starts with defining the steps and how they connect:

# Example: Research-to-Presentation Flow
{
  "name": "research-presentation-pipeline",
  "steps": [
    {
      "id": "research",
      "skill": "literature-search",
      "params": {
        "query": "${input.topic}",
        "limit": 20,
        "sources": ["google_scholar", "pubmed"]
      }
    },
    {
      "id": "analysis",
      "skill": "academic-deep-research",
      "depends_on": ["research"],
      "params": {
        "papers": "${research.papers}",
        "focus": "${input.analysis_focus}"
      }
    },
    {
      "id": "slides",
      "skill": "pptx-generator",
      "depends_on": ["analysis"],
      "params": {
        "content": "${analysis.summary}",
        "template": "academic",
        "slides_count": 15
      }
    }
  ]
}

🔀 Conditional Logic

ClawFlows supports splitting the flow on conditions:

# Conditional branching example
{
  "steps": [
    {
      "id": "content_check",
      "skill": "content-analyzer",
      "params": {"text": "${input.content}"}
    },
    {
      "id": "seo_optimize",
      "skill": "seo-content-writer",
      "condition": "${content_check.type} == 'blog_post'",
      "depends_on": ["content_check"]
    },
    {
      "id": "academic_format",
      "skill": "academic-writing-refiner",
      "condition": "${content_check.type} == 'research'",
      "depends_on": ["content_check"]
    }
  ]
}

📊 Data Flow Management

Passing data between skills is flexible:

# Data transformation and filtering
{
  "steps": [
    {
      "id": "collect_data",
      "skill": "web-scraper",
      "params": {"urls": "${input.urls}"}
    },
    {
      "id": "process_data",
      "skill": "data-analyzer",
      "params": {
        "data": "${collect_data.results | filter(quality > 0.8)}",
        "format": "structured"
      }
    },
    {
      "id": "generate_report",
      "skill": "report-generator",
      "params": {
        "data": "${process_data.analysis}",
        "template": "executive_summary"
      }
    }
  ]
}

🚀 Running ClawFlows

# search the available flows
clawflows search "content creation"

# install a flow from the marketplace
clawflows install research-presentation-pipeline

# run a flow with parameters
clawflows run research-presentation-pipeline \
  --topic "AI in Healthcare" \
  --analysis_focus "clinical_applications"

# watch the execution progress
clawflows status research-presentation-pipeline-run-123

⚙️ Automation Patterns — Automation With a System Behind It

OpenClaw skills do not only run when they are called. They can be set to run automatically on a schedule, on an event, or on a condition — and that is what turns them into a powerful automation ecosystem.

⏰ Cron-Driven Skill Execution

Setting skills to run at fixed times:

# cron automation examples
# every morning at 08:00, produce the daily research summary
0 8 * * * openclaw run literature-search "AI healthcare advances" --daily-summary

# every Monday, build the weekly report
0 9 * * 1 openclaw run academic-deep-research --weekly-summary --email-to [email protected]

# every 30 minutes, check for important email
*/30 * * * * openclaw run himalaya --check-urgent --notify-if-important

# at month end, generate the performance report
0 2 1 * * clawflows run monthly-performance-report

🎯 Event-Triggered Skills

Skills that run when a particular event happens:

# Webhook triggers
# when a new paper lands on ArXiv
curl -X POST localhost:3000/webhook/arxiv \
  -d '{"papers": ["2401.12345"], "topic": "machine_learning"}'
# → trigger literature-review skill

# when the smart home detects motion
curl -X POST localhost:3000/webhook/home-assistant \
  -d '{"entity": "binary_sensor.motion", "state": "on"}'
# → trigger security-alert skill

# when there is a new Git commit
curl -X POST localhost:3000/webhook/github \
  -d '{"repository": "my-project", "branch": "main"}'
# → trigger the code-review and documentation skills

💓 Heartbeat-Integrated Tasks

Skills folded into the OpenClaw heartbeat system:

# in the HEARTBEAT.md configuration
{
  "checks": [
    {
      "name": "email_priority_check",
      "skill": "himalaya",
      "params": {"filter": "urgent", "action": "notify"},
      "frequency": "every_30_minutes"
    },
    {
      "name": "arxiv_updates",
      "skill": "arxiv-watcher",
      "params": {"topics": ["AI", "ML"], "notify_on_new": true},
      "frequency": "daily_morning"
    },
    {
      "name": "system_health",
      "skill": "healthcheck",
      "params": {"full_scan": false, "alert_threshold": "medium"},
      "frequency": "every_4_hours"
    }
  ]
}

🔄 Batch Processing Patterns

Processing large volumes of data with skills:

# Batch document processing
for file in documents/*.pdf; do
  openclaw run pdf-to-structured "$file" --output-dir processed/
done

# Parallel batch processing
ls images/*.jpg | xargs -P 4 -I {} openclaw run image-analyzer {} --format json

# ClawFlow batch processing
clawflows run bulk-document-processor \
  --input-dir /data/documents \
  --output-format json \
  --parallel-workers 8

⚖️ Building vs Buying Skills — Choosing the Strategy That Fits Your Organization

Deciding whether to build a custom skill yourself or use one that already exists on ClawHub is an important question, and it takes an analysis of cost, benefit, and the particular needs of each organization.

🛒 When to "Buy" (Use ClawHub Skills)

🔨 When to "Build" (Create Custom Skills)

💰 Cost-Benefit Analysis Framework

# Costing out Build vs Buy

## Build Costs:
- Development time: 40-120 hours (depending on complexity)
- Developer salary: $50-150/hour
- Testing & QA: 20% of development time
- Documentation: 10% of development time
- Ongoing maintenance: 15-25% annually

## Buy Costs:
- Skill license: $0-50/month (most are free)
- Integration time: 2-8 hours
- Customization: 0-16 hours
- Learning curve: 4-12 hours

## Typical ROI Timeline:
- Simple skills: Buy wins if usage < 6 months
- Medium complexity: Break-even at 12-18 months
- Complex skills: Build wins if usage > 24 months

🔄 Hybrid Strategy

The strategy that blends the best of both approaches:

📊 Decision Matrix

# Skill Decision Scorecard (1-5 scale)

Factors favoring BUILD:
□ Uniqueness requirement (1=generic, 5=highly specific)
□ Security sensitivity (1=public OK, 5=highly sensitive)
□ Integration complexity (1=standalone, 5=deep integration)
□ Long-term usage (1=short-term, 5=multi-year)
□ Available resources (1=limited, 5=dedicated team)

Factors favoring BUY:
□ Time urgency (1=flexible, 5=urgent)
□ Standard use case (1=unique, 5=common pattern)
□ Community support (1=niche, 5=popular)
□ Cost sensitivity (1=budget flexible, 5=cost-critical)
□ Risk tolerance (1=high risk OK, 5=low risk only)

Score > 20: Consider BUILD
Score < 15: Consider BUY
Score 15-20: Hybrid approach