OpenClaw comes with useful skills out of the box — weather lookups, Slack messaging, health checks. But here’s the thing: those are generic. They work for anyone. The real power of OpenClaw kicks in when you build skills that solve your problems, for your trade.

A plumber dealing with warranty callbacks needs different tools than an electrician tracking permit approvals. A GC running five crews needs a daily report that looks nothing like what a solo painter would use.

Custom skills let you teach OpenClaw how your business actually works. No coding degree required. If you can write a text file and copy a shell script, you can build a skill.

This guide walks you through the whole process — from a dead-simple first skill to a full-blown estimate generator with templates. By the end, you’ll have the knowledge to build any skill your trade needs.

If you haven’t set up OpenClaw yet, start with our OpenClaw setup guide first. Already running? Let’s build.

What Are OpenClaw Skills (and Why Should You Care)?

A skill is a folder with instructions that teach your OpenClaw agent how to do something new. That’s it. No plugins to install, no API keys to configure (usually), no app store approval process.

Think of it like hiring a new employee. You don’t reprogram their brain — you hand them a procedure manual. “Here’s how we handle warranty claims. Here’s the form. Here’s where to file it.” OpenClaw skills work the same way.

Each skill is a directory containing:

  • A SKILL.md file — the instruction manual your agent reads
  • Scripts — optional shell scripts that do the heavy lifting
  • Templates — optional files your agent fills in (estimates, reports, checklists)
  • Reference files — anything else the agent might need (price lists, code tables, spec sheets)

When your agent gets a request that matches a skill’s description, it reads that skill’s SKILL.md and follows the instructions. Simple as that.

Why this matters for contractors:

  • You don’t need to wait for someone else to build the tool you need
  • Your skills reflect how your business operates, not some generic workflow
  • Skills are portable — move them between machines, share them with your team
  • You can publish skills to ClawHub and help other contractors in your trade

We covered some pre-built options in our roundup of the best OpenClaw skills for contractors. But the skills you build yourself? Those are the ones that give you a real edge.

Anatomy of a Skill

Every skill lives in a folder inside your OpenClaw workspace. Here’s the basic structure:

~/.openclaw/workspace/skills/
└── my-skill/
    ├── SKILL.md          ← Required: instructions for your agent
    ├── run.sh            ← Optional: shell script
    ├── template.md       ← Optional: template file
    └── reference-data/   ← Optional: supporting files
        └── prices.csv

The SKILL.md File

This is the only required file. It tells your agent three things:

  1. What the skill does (so the agent knows when to use it)
  2. How to use it (step-by-step instructions)
  3. Where to find supporting files (scripts, templates, data)

Here’s the basic format:

# Skill Name

## Description
One or two sentences explaining what this skill does.
This is what the agent matches against when deciding which skill to use.

## Instructions
Step-by-step directions for the agent to follow.
Be specific. Write like you're training a new office manager.

## References
- `run.sh` — Script that pulls data from the API
- `template.md` — Output template for the report

The description is critical. Your agent scans all available skill descriptions to decide which one to use for a given task. Make it clear and specific. “Generate daily crew reports for active job sites” is better than “reporting tool.”

How Skills Get Registered

Your agent’s configuration includes an available_skills list. Each entry has a name, description, and file path. When a task matches a skill’s description, the agent reads that skill’s SKILL.md and follows the instructions inside.

You register skills by placing them in your workspace’s skills/ directory (or wherever your OpenClaw instance looks for them). The agent picks them up automatically.

Building Your First Skill: Daily Job Summary

Let’s start simple. We’ll build a skill that generates a daily summary of active jobs — something every contractor checks first thing in the morning.

Step 1: Create the Skill Directory

mkdir -p ~/.openclaw/workspace/skills/daily-job-summary

Step 2: Write the SKILL.md

# Daily Job Summary

## Description
Generate a daily summary of active jobs including status,
crew assignments, and today's priorities. Use when the user
asks for a daily summary, morning report, or job status update.

## Instructions

1. Read the active jobs file at `jobs/active-jobs.json`
2. For each active job, summarize:
   - Job name and address
   - Current phase (demo, rough-in, finish, punch list, etc.)
   - Crew assigned today
   - Any notes or flags
3. Sort by priority (flagged jobs first, then by phase)
4. Format output using the template at `template.md`
5. Include today's date and total active job count at the top

## Notes
- If a job has a flag or note marked "urgent," put it at the top
- Keep descriptions brief — one line per job
- Include weather note if the weather skill is available

## References
- `template.md` — Output format template
- `jobs/active-jobs.json` — Active jobs data (user maintains this)

Step 3: Create the Template

Create ~/.openclaw/workspace/skills/daily-job-summary/template.md:

# Daily Job Summary — {{date}}

**Active Jobs:** {{total_count}}

{{#if urgent_jobs}}
## 🔴 Urgent
{{#each urgent_jobs}}
- **{{name}}** ({{address}}) — {{phase}} — {{note}}
{{/each}}
{{/if}}

## Today's Jobs

{{#each jobs}}
### {{name}}
- **Address:** {{address}}
- **Phase:** {{phase}}
- **Crew:** {{crew}}
- **Notes:** {{notes}}
{{/each}}

---
Generated by OpenClaw • {{date}}

Step 4: Add Sample Data

Create ~/.openclaw/workspace/skills/daily-job-summary/jobs/active-jobs.json:

[
  {
    "name": "Henderson Kitchen Remodel",
    "address": "442 Oak St",
    "phase": "Rough-in",
    "crew": "Team A — Mike, Carlos, Devon",
    "notes": "Plumber scheduled 10am for rough-in inspection",
    "urgent": false
  },
  {
    "name": "Westfield Bathroom",
    "address": "1201 Maple Dr",
    "phase": "Demo",
    "crew": "Team B — Jake, Luis",
    "notes": "Asbestos test results pending — DO NOT proceed until cleared",
    "urgent": true
  }
]

Step 5: Test It

Open OpenClaw and type: “Give me my daily job summary.”

Your agent should match the request to the skill, read the SKILL.md, pull in the active jobs data, and produce a formatted report. If the output doesn’t look right, tweak the instructions in SKILL.md. The agent follows what you wrote — if the output is wrong, the instructions are usually the problem.

That’s a working skill in five minutes. No code, no APIs, no dependencies.

Building a Complex Skill: Estimate Generator

Now let’s build something with more moving parts. This skill generates job estimates using templates, material price references, and labor rate calculations. It’s the kind of tool that saves hours every week.

The File Structure

~/.openclaw/workspace/skills/estimate-generator/
├── SKILL.md
├── generate-estimate.sh
├── templates/
│   ├── residential-remodel.md
│   ├── new-construction.md
│   └── service-call.md
├── data/
│   ├── labor-rates.json
│   ├── material-prices.csv
│   └── markup-table.json
└── output/
    └── (generated estimates go here)

The SKILL.md

# Estimate Generator

## Description
Generate professional job estimates for residential remodeling,
new construction, and service calls. Use when the user asks to
create an estimate, bid, quote, or proposal for a job.

## Instructions

### Gathering Information
1. Ask the user for:
   - Job type (remodel, new construction, service call)
   - Scope of work (what rooms/systems, square footage)
   - Job address
   - Customer name
   - Any special conditions (access issues, permits needed, etc.)

### Building the Estimate
2. Select the correct template from `templates/` based on job type
3. Load labor rates from `data/labor-rates.json`
4. Load material prices from `data/material-prices.csv`
5. Load markup percentages from `data/markup-table.json`
6. Calculate line items:
   - Material cost = quantity × unit price from price list
   - Labor cost = estimated hours × hourly rate for that trade
   - Subtotal = materials + labor
   - Markup = subtotal × markup percentage for job type
   - Total = subtotal + markup
7. Run `generate-estimate.sh` with the output file path to
   generate a PDF-ready version

### Output
8. Save the estimate to `output/estimate-{{customer}}-{{date}}.md`
9. Present a summary to the user with the total and file location

## Important
- Always round line items to nearest dollar
- Include a 10% contingency line for remodels
- Material prices are updated monthly — check the date in
  material-prices.csv header
- Do NOT adjust markup percentages without asking the user

## References
- `templates/residential-remodel.md` — Remodel estimate template
- `templates/new-construction.md` — New build estimate template
- `templates/service-call.md` — Service/repair call template
- `data/labor-rates.json` — Current labor rates by trade
- `data/material-prices.csv` — Material pricing (updated monthly)
- `data/markup-table.json` — Markup percentages by job type
- `generate-estimate.sh` — Script to format final output

Labor Rates Reference

Create data/labor-rates.json:

{
  "updated": "2026-03-01",
  "rates": {
    "general_labor": 35,
    "carpenter": 55,
    "electrician": 75,
    "plumber": 75,
    "hvac_tech": 70,
    "painter": 45,
    "tile_setter": 60,
    "drywall": 50,
    "roofing": 55,
    "concrete": 50
  },
  "overtime_multiplier": 1.5,
  "notes": "Rates are per hour, burdened (includes insurance, taxes)"
}

Material Prices Reference

Create data/material-prices.csv:

# Updated: 2026-03-01 | Source: Local supplier quotes
item,unit,price,category
2x4x8 SPF,each,4.25,lumber
2x6x8 SPF,each,6.75,lumber
3/4 plywood,sheet,52.00,lumber
1/2 drywall 4x8,sheet,14.50,drywall
joint compound 5gal,bucket,18.00,drywall
12/2 NM-B wire,roll (250ft),89.00,electrical
20A breaker,each,8.50,electrical
1/2 copper pipe,foot,4.25,plumbing
PEX 1/2,roll (100ft),45.00,plumbing
R-19 insulation,roll,42.00,insulation
interior paint,gallon,38.00,paint
exterior paint,gallon,45.00,paint

Markup Table

Create data/markup-table.json:

{
  "residential_remodel": {
    "markup_percent": 35,
    "contingency_percent": 10,
    "notes": "Standard remodel markup — adjust for complexity"
  },
  "new_construction": {
    "markup_percent": 25,
    "contingency_percent": 5,
    "notes": "Lower margin, higher volume"
  },
  "service_call": {
    "markup_percent": 50,
    "contingency_percent": 0,
    "notes": "Service calls include trip charge in markup"
  }
}

Estimate Template

Create templates/residential-remodel.md:

# Estimate

**Prepared for:** {{customer_name}}
**Job Address:** {{job_address}}
**Date:** {{date}}
**Estimate #:** {{estimate_number}}

---

## Scope of Work
{{scope_description}}

## Cost Breakdown

### Materials
| Item | Qty | Unit Price | Total |
|------|-----|-----------|-------|
{{#each materials}}
| {{item}} | {{qty}} | ${{unit_price}} | ${{total}} |
{{/each}}
| **Materials Subtotal** | | | **${{materials_subtotal}}** |

### Labor
| Trade | Hours | Rate | Total |
|-------|-------|------|-------|
{{#each labor}}
| {{trade}} | {{hours}} | ${{rate}}/hr | ${{total}} |
{{/each}}
| **Labor Subtotal** | | | **${{labor_subtotal}}** |

### Summary
| | |
|---|---|
| Materials | ${{materials_subtotal}} |
| Labor | ${{labor_subtotal}} |
| **Subtotal** | **${{subtotal}}** |
| Contingency (10%) | ${{contingency}} |
| **Total Estimate** | **${{grand_total}}** |

---

*This estimate is valid for 30 days from the date above.*
*Changes to scope may affect final pricing.*

The Shell Script

Create generate-estimate.sh:

#!/bin/bash
# generate-estimate.sh — Format estimate for output
# Usage: ./generate-estimate.sh output-file.md

OUTPUT_FILE="$1"

if [ -z "$OUTPUT_FILE" ]; then
    echo "Usage: generate-estimate.sh <output-file>"
    exit 1
fi

# Verify the file exists
if [ ! -f "$OUTPUT_FILE" ]; then
    echo "Error: Output file not found at $OUTPUT_FILE"
    exit 1
fi

# Add generation timestamp
echo "" >> "$OUTPUT_FILE"
echo "---" >> "$OUTPUT_FILE"
echo "*Generated by OpenClaw Estimate Generator on $(date '+%Y-%m-%d at %I:%M %p')*" >> "$OUTPUT_FILE"

echo "Estimate saved to: $OUTPUT_FILE"

Make it executable:

chmod +x ~/.openclaw/workspace/skills/estimate-generator/generate-estimate.sh

Using the Skill

Now when you tell OpenClaw “I need an estimate for the Johnson bathroom remodel — gut and redo, about 80 square feet,” it will:

  1. Match the request to the estimate generator skill
  2. Ask follow-up questions (customer name, address, specifics)
  3. Pull in current material prices and labor rates
  4. Calculate everything with proper markup
  5. Output a clean, professional estimate

One conversation. No spreadsheets. No digging through old bids to copy-paste.

Testing and Debugging Skills

Skills don’t always work perfectly the first time. Here’s how to troubleshoot:

Common Issues and Fixes

Agent doesn’t pick up the skill:

  • Check that the skill description matches the kind of request you’re making. If your description says “Generate quarterly profit reports” but you ask for a “Q1 summary,” the agent might not connect the dots. Use the words your users would actually say.

Agent reads the skill but does it wrong:

  • Your instructions aren’t specific enough. Remember — the agent follows what you wrote literally. If you wrote “summarize the jobs” but wanted a specific format, spell out that format.

Script errors:

  • Run your scripts manually first: bash ./run.sh — fix any errors before involving the agent.
  • Check file permissions: chmod +x script.sh
  • Make sure file paths in your SKILL.md match the actual file locations.

Missing data:

  • If your skill references a data file that doesn’t exist, the agent will tell you. Create sample data files so the skill works even before you populate real data.

Testing Workflow

  1. Read your SKILL.md out loud. If it doesn’t make sense to a human, it won’t make sense to the agent.
  2. Run scripts manually. Test every shell script in your terminal before connecting it to a skill.
  3. Start with a simple request. Don’t test the complex edge cases first — make sure the basic flow works.
  4. Check the agent’s output. If it’s not right, adjust the SKILL.md instructions and try again.
  5. Iterate fast. Skills are just text files. Edit, save, re-test. No compile step, no restart needed.

The beauty of this system is the feedback loop. Your agent tells you what it tried and what went wrong. Fix the instruction, try again. Most skills work correctly within two or three tweaks.

Publishing to ClawHub

Built something useful? Other contractors in your trade probably need it too.

ClawHub is the community marketplace for OpenClaw skills. Publishing is straightforward:

Prep Your Skill for Sharing

  1. Remove personal data. Replace your actual labor rates, customer info, and business details with sample data. Include a README.md explaining what to customize.

  2. Add a clawhub.json metadata file:

{
  "name": "estimate-generator",
  "version": "1.0.0",
  "description": "Generate professional job estimates with material and labor calculations",
  "author": "your-username",
  "trade": ["general-contractor", "remodeling"],
  "tags": ["estimating", "bidding", "proposals"],
  "license": "MIT"
}
  1. Write a clear README.md covering:
    • What the skill does
    • What data files the user needs to customize
    • Any dependencies (external tools, API keys, etc.)

Publish

openclaw skill publish ./skills/estimate-generator

That packages your skill directory and pushes it to ClawHub. Other OpenClaw users can install it with:

openclaw skill install estimate-generator

If you’ve already found useful community skills, check out our list of the best OpenClaw skills for contractors to see what’s available.

Skills Every Contractor Should Build

Here are practical skill ideas organized by what they solve. Pick the ones that match your biggest time sinks.

Warranty Tracker

Tracks warranty expiration dates for completed jobs. The agent checks your warranty log daily and alerts you when warranties are approaching expiration — so you can schedule callbacks before they become complaints.

What you’d need:

  • A warranties.json file with job name, completion date, warranty period, and customer contact
  • SKILL.md instructions to check dates and flag anything expiring within 30 days
  • A simple notification template

Who it’s for: Any contractor who offers labor warranties. Especially GCs and HVAC contractors.

Material Price Checker

Pulls current pricing from your supplier’s portal or a reference file you maintain. When you’re putting together a bid, ask OpenClaw “What’s the current price on 3/4 CDX plywood?” and get an answer without logging into three different websites.

What you’d need:

  • A script that checks your supplier’s price list (or a manually updated CSV)
  • SKILL.md instructions to look up items and report pricing with date of last update
  • Optional: alert when prices change more than 10% from your reference

Who it’s for: Anyone who bids jobs. Price volatility on lumber, copper, and steel makes this especially valuable for GCs, framers, plumbers, and electricians.

Permit Status Checker

Monitors permit applications and alerts you when status changes. Instead of checking the county website every morning, your agent does it and tells you what moved.

What you’d need:

  • A permits.json file with permit numbers, jurisdiction, and current status
  • A script that checks the local jurisdiction’s permit portal (this varies by county — some have APIs, some need web scraping)
  • SKILL.md instructions to compare current status against last known status and report changes

Who it’s for: GCs and any trade that pulls permits regularly. Electricians and plumbers especially — permit delays kill schedules.

Daily Crew Report Generator

Your crews text in their updates. This skill compiles those updates into a formatted daily report — hours worked, work completed, materials used, issues encountered.

What you’d need:

  • A structured input format (even a simple text file each crew lead fills out)
  • A template for the compiled report
  • SKILL.md instructions to pull all crew inputs, merge them, and generate the report

Who it’s for: Any contractor running multiple crews. GCs managing subs. Landscaping companies with 3+ teams out daily.

Safety Compliance Checklist

Generates job-specific safety checklists based on the type of work being done. Tell OpenClaw “We’re doing a roof tear-off at 1440 Elm tomorrow” and it produces a checklist covering fall protection, debris management, weather considerations, and required PPE.

What you’d need:

  • Reference files with OSHA requirements by work type
  • Templates for different job categories
  • SKILL.md instructions to match job type to relevant safety requirements

Who it’s for: Every contractor. Period. See our guide on using OpenClaw for safety compliance for more on this.

Client Update Drafter

Drafts professional status updates for your clients. Feed it the job progress notes and it produces a clean email you can review and send. Beats typing the same “Your kitchen is on track, tile goes in Thursday” message from scratch every time.

What you’d need:

  • A template with your company header and sign-off
  • SKILL.md instructions for tone (professional but warm, no jargon)
  • Reference to the active jobs data so it pulls the right project details

Who it’s for: Any contractor who communicates with homeowners. Remodelers, custom builders, and specialty trades doing direct-to-consumer work.

Putting It All Together

Custom skills are where OpenClaw goes from “cool AI tool” to “I can’t run my business without this.” The pattern is always the same:

  1. Identify something you do repeatedly
  2. Write instructions for how you do it
  3. Add any data or templates you use
  4. Let the agent handle it

Start with one simple skill. The daily job summary is a great first build — it takes five minutes, and you’ll use it every morning. Once that works, tackle something bigger like the estimate generator.

If you’re already automating daily tasks with OpenClaw, custom skills are the natural next step. And if you’re thinking about scaling to building a multi-agent AI team, skills become even more powerful — each agent can have specialized skills for its role.

The contractors who will win in the next few years aren’t the ones with the biggest crews. They’re the ones who build systems that make their existing crew unstoppable. Custom OpenClaw skills are one of the most direct ways to do that.

Your first skill is waiting. Go build it.