Skills & Slash Commands

The reason this matters: keeping procedures out of your always-on memory files keeps those files lean. A deployment checklist in AGENTS.md costs tokens on every single message. As a skill, it only costs tokens when you actually need to deploy.

Every skill is a directory with a required SKILL.md entrypoint. The directory name becomes the slash command:

.claude/skills/status/
└── SKILL.md         ← becomes /status

.claude/skills/deploy-check/
├── SKILL.md         ← becomes /deploy-check
└── checklist.md     ← supporting file the skill can reference

Skills can live in three places depending on their scope:

When you first run claude or go through the OpenClaw onboarding, you'll see prompts about skills and plugins. Here's what those prompts are actually offering:

Before diving into features — here's the simplest possible skill to make the format concrete. Create this file and you immediately have a /hello command:

mkdir -p ~/.claude/skills/hello
nano ~/.claude/skills/hello/SKILL.md

---
description: Quick test that skill loading is working
---

Say hello and confirm which skills are currently loaded.

Type /hello in your next session. That's it — the agent reads the SKILL.md and follows the instructions. The description frontmatter is what lets the agent decide to use this skill automatically when it's relevant.

/batch is for large-scale changes that can be broken into independent units. It analyzes your codebase, decomposes the task into 5–30 parallel workstreams, spawns a separate agent for each one in an isolated git worktree, and opens pull requests when done. Work that would take hours of sequential back-and-forth completes in parallel.

/batch Add JSDoc comments to all exported functions in src/

/batch Migrate all fetch() calls to use the new apiClient wrapper

/batch Update all components to use the new Button component instead of raw <button>

/simplify spawns three parallel review agents focused on different lenses: code quality, reusability, and efficiency. Their findings are aggregated and applied to the code you specify. It's the closest thing to a real peer review you can get from a single tool.

# Review your current open files
/simplify

# Focus on a specific aspect
/simplify focus on error handling

# Point at a specific file
/simplify src/auth/tokenManager.ts

Use it after you think a piece of code is done. The three-agent structure catches things a single review pass misses — one agent tends to focus on what you intended, while another is reading the code fresh and catching what you've gone blind to after staring at it.

/loop runs a prompt repeatedly at a specified interval until you stop it or a condition is met. Useful for babysitting long-running processes without manually polling.

# Check a deploy every 30 seconds
/loop 30 Check the deploy status at https://api.example.com/health and report if it's up

# Watch a build log for errors
/loop 10 tail -20 /var/log/build.log and alert me if you see any ERROR lines

# Monitor disk space during a large operation
/loop 60 Run df -h and warn me if any filesystem is above 85%

Stop the loop by sending /loop stop or just starting a new prompt. Particularly useful when running on a server via Discord — you can start a loop and walk away, getting notifications if something needs attention.

/debug reads Claude Code's own internal session debug log and helps you understand what's happening when something isn't working. Useful when:

• A skill isn't appearing in the slash command menu
• A hook isn't firing when you expect it to
• Memory files don't seem to be loading
• An API tool call is silently failing
• The context window is behaving unexpectedly

/debug

/debug my /status skill isn't showing up in the command menu

/debug the PreToolUse hook doesn't seem to be blocking Bash commands

To see every skill currently loaded in your session, type:

/help

This lists all available slash commands — built-in skills, community skills you've installed, and any custom skills you've written. If a skill you created isn't showing up here, check the file path and frontmatter (more in the Tips section).

To see what's consuming your context budget (relevant when you have many skills installed):

/context

Skills compete for a context budget of about 16,000 characters (2% of the context window). If you have more skills than fit, Claude trims the least recently used. /context shows you exactly what made the cut and what didn't.

The universal skill installer. Works across Claude Code, Cursor, Cline, and 40+ other AI tools — but we're focused on Claude Code here. Install a skill repo in one command:

# Install all skills from a repo globally (available in all projects)
npx skills add github.com/anthropics/skills -g

# Install a single skill from a repo
npx skills add github.com/anthropics/skills --skill frontend-design -g

# Preview what's in a repo before installing
npx skills add github.com/anthropics/skills --list

# Install to current project only (no -g flag)
npx skills add github.com/anthropics/skills --skill webapp-testing

The -g flag installs to ~/.claude/skills/ (global, all projects). Without it, skills go to .claude/skills/ in your current directory (project-only, safe to commit).

These ship from Anthropic's own repository. Maintained, tested, and worth having:

npx skills add github.com/anthropics/skills -g

The most-installed community skills library. Focused on frontend and web development:

npx skills add github.com/vercel-labs/agent-skills -g

The most complete development workflow skill library. Built around the idea that planning and execution should be separate phases, with subagents handling implementation.

npx skills add obra/superpowers -g

Professional-grade security audit methodology from Trail of Bits, the security research firm. Particularly relevant if you're running a server exposed to the internet (which you are if you followed the EC2 tutorial).

npx skills add trailofbits/skills -g

Covers CodeQL and Semgrep analysis, structured code auditing methodology, and variant analysis (finding all instances of a class of vulnerability, not just the one you spotted). Run it against your OpenClaw configuration and server setup — you may find things.

The /plugin command opens the official Anthropic marketplace directly in your session. Some of the highest-value plugins for this audience:

# Browse the marketplace
/plugin

# Install directly if you know the plugin name
/plugin install typescript-lsp@claude-plugins-official
/plugin install github@claude-plugins-official
/plugin install commit-commands@claude-plugins-official

The frontmatter block (the --- section at the top) controls how and when your skill gets used. Most fields are optional — the body text is the only strict requirement. Here are the ones that matter most:

---
name: deploy-check
description: Run pre-deployment checks — tests, lint, env vars, disk space
argument-hint: [environment]
disable-model-invocation: true
allowed-tools: Bash, Read
context: fork
---

Your skill instructions here...

Skills aren't static documents — they can pull in live data and accept arguments:

---
description: Summarize recent changes on the current branch
argument-hint: [branch-name]
allowed-tools: Bash(git *)
---

Branch: !`git branch --show-current`
Recent commits: !`git log --oneline -10`
Diff summary: !`git diff --stat HEAD~5`

Summarize what changed in the last 5 commits.
Target environment: $ARGUMENTS

When this skill runs, Claude receives the actual branch name, the real commit list, and the real diff stats — not a request to go find them. The skill front-loads the research.

A server health check skill built specifically for OpenClaw users. One command gives you a full picture of your server state: gateway, Docker, disk, memory, and recent logs. This skill lives in your global ~/.claude/skills/ directory so it's available everywhere.

mkdir -p ~/.claude/skills/status
nano ~/.claude/skills/status/SKILL.md

---
description: Full server health check — OpenClaw gateway, Docker, disk, memory, and recent error logs
allowed-tools: Bash
disable-model-invocation: true
---

Run each of the following checks and compile a clear health report:

## 1. OpenClaw Gateway
Run: `openclaw status`
Report: running/stopped, uptime, version if available

## 2. Docker Containers
Run: `docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"`
Report: which containers are up, which are down or restarting

## 3. Disk Usage
Run: `df -h --output=source,size,used,avail,pcent | grep -v tmpfs`
Report: flag any filesystem above 80% usage

## 4. Memory
Run: `free -h`
Report: total, used, available RAM — flag if available drops below 1GB

## 5. Recent Errors
Run: `openclaw logs --tail 20 2>/dev/null || journalctl -u openclaw --since "1 hour ago" --no-pager -q 2>/dev/null`
Report: any ERROR or WARN lines from the last hour

---

Format the output as a short dashboard summary.
Use ✅ for healthy, ⚠️ for warning, ❌ for critical.
End with a one-line overall status: HEALTHY / DEGRADED / CRITICAL.

Type /status in any session and you get a formatted report in seconds. No flags to remember, no commands to look up, no mentally assembling the pieces yourself.

A pre-flight checklist that runs before any deployment. Catches the things you always forget: uncommitted changes, failing tests, exposed environment variables, missing config keys. Scoped to a project directory, committed to git so your team inherits it.

mkdir -p .claude/skills/deploy-check
nano .claude/skills/deploy-check/SKILL.md

---
description: Pre-deployment checklist — git status, tests, env vars, and config validation
argument-hint: [staging|production]
allowed-tools: Bash, Read
disable-model-invocation: true
---

Target environment: $ARGUMENTS

Run each check and report pass ✅ / fail ❌:

## Git
- [ ] No uncommitted changes: `git status --short`
- [ ] On the correct branch for $ARGUMENTS deployment
- [ ] No merge conflicts: `git diff --check`

## Tests
- [ ] Run: `npm test 2>&1 | tail -20` (or your test command)
- [ ] All tests passing

## Environment
- [ ] .env file is NOT committed: `git ls-files .env`
- [ ] Required env vars present: `printenv | grep -E "^(DATABASE_URL|API_KEY|NODE_ENV)"`
  (update this list with your actual required vars)

## Disk & Memory
- [ ] Sufficient disk space: `df -h .`
- [ ] Sufficient memory: `free -h`

---

If any checks fail, stop and describe exactly what needs to be fixed before deploying.
Do not proceed past a failing check — the purpose of this skill is to catch problems, not confirm them.

Commit this file and everyone on your team has the same pre-deployment checklist. It also doubles as documentation — new team members learn your deployment requirements by reading the skill.

git add .claude/skills/deploy-check/SKILL.md
git commit -m "Add deploy-check skill for pre-deployment validation"

A few more patterns worth knowing as you build your own library:

Type /help in your session. If your skill isn't listed, work through this checklist:

# Check your global skills directory
ls -la ~/.claude/skills/

# Each item should be a directory containing SKILL.md
ls -la ~/.claude/skills/status/

# File permissions — SKILL.md needs to be readable
chmod 644 ~/.claude/skills/status/SKILL.md

Claude uses a skill automatically when the description frontmatter matches what you're asking about. If auto-invocation isn't working, the description probably isn't descriptive enough — or auto-invocation is disabled.

The !`command` syntax runs the command at skill load time. If it's not executing:

Once you've built up a library of skills, a few practices keep it maintainable:

# List all global skills with their SKILL.md descriptions
for dir in ~/.claude/skills/*/; do
  name=$(basename "$dir")
  desc=$(grep "^description:" "$dir/SKILL.md" 2>/dev/null | head -1)
  echo "$name — $desc"
done

# Check total character count of all skill descriptions
wc -c ~/.claude/skills/*/SKILL.md | sort -rn | head -20