On this page

45 minutes per PR review. 20 minutes triaging Jira. 30 minutes writing release notes. That's 2 hours a day on work that isn't writing code.

Your agent can handle most of it.

OpenClaw skills are mini-integrations — each one gives your agent access to an external tool. Install them from ClawHub, which now has 5,400+ community skills. Or write your own as a custom markdown file.

This guide covers the 8 skills that eliminate the most developer meta-work. Each one has a specific install command, a real example prompt, and honest notes on what works and what doesn't.

Developer surrounded by floating sticky notes showing hours lost to PR reviews, Jira triage, and release notesBlink

What OpenClaw skills are

A skill is a SKILL.md file — plain markdown instructions that tell your agent how to do something specific. When you install a skill, the agent reads it before deciding how to approach a relevant task.

Skills don't require code. They describe a workflow in natural language: what triggers this, what steps to follow, what the output should look like.

Install from ClawHub via the UI or via terminal:

npx clawhub install <skill-name>

You can also write custom skills for your own internal tools — more on that at the end.

The 8 skills every developer needs

GitHub skill: automated PR reviews while you sleep

The GitHub skill connects to your repositories via a personal access token. It handles three tasks developers waste the most time on: summarizing new PRs, triaging new issues, and generating release notes from merged commits.

Best use case: Configure it to trigger on pull_request.opened. Every new PR gets a summary — changed files, risk level, suggested reviewers, and any obvious problems the agent spotted. You open the PR already knowing the context.

Example prompt:

"Summarize PR #847 — list changed files, estimate risk level, flag any missing tests, and suggest a reviewer based on file ownership."

npx clawhub install github

Code Review skill: catch issues before you push

The Code Review skill performs a reasoning-layer analysis on your diff — not a linter pass. It finds logic errors, security patterns, and missing error handling that static analysis misses.

Best use case: Trigger it on pull_request.ready_for_review, before human reviewers see the PR. It posts inline review comments on GitHub directly. You fix the obvious problems before asking colleagues to spend their time.

Example prompt:

"Review the changes in this PR for security issues, logic errors, and missing error handling. Post comments directly on the relevant lines."

npx clawhub install code-review

The Code Review skill degrades on PRs over 400 changed lines — you get a summary review instead of line-level comments. Keep PRs focused or run it per-file on large diffs.

Terminal/Shell skill: run commands autonomously

The Terminal skill lets your agent execute shell commands, run scripts, and interact with your server environment. Git, curl, bash, python3, npm — all available.

Best use case: Checking server status, running database migrations, executing one-off scripts, or automating anything that lives on the command line.

Example prompt:

"Check disk usage on the staging server, list processes consuming more than 5% CPU, and ping the /health endpoint."

npx clawhub install terminal

Scope the Terminal skill's permissions explicitly before deploying in production. An agent with unrestricted shell access and a vague instruction can make unintended changes. Define allowed directories and commands in the skill's config block.

Memory skill: remember your stack, conventions, and patterns

The Memory skill gives your agent persistent context across sessions. Tell it your tech stack, preferred patterns, naming conventions, and code style once. It references that context on every future task.

Best use case: Onboarding the agent to your codebase. Run one setup session where you describe your architecture, testing approach, and team conventions. Every subsequent request benefits from that context without re-explaining.

Example prompt:

"Remember that this project uses TypeScript strict mode, Prisma for database access, and Jest for testing. All API routes should include Zod schema validation."

npx clawhub install memory

Web Search skill: research docs while you code

The Web Search skill gives your agent real-time access to documentation, StackOverflow, GitHub issues, and the web at large. It's particularly useful when you're debugging an error message or researching an unfamiliar library.

Best use case: Error investigation. Drop an error message or a stack trace and ask the agent to research it. It searches across docs, GitHub issues, and StackOverflow and returns a synthesized answer — not a list of links to click through.

Example prompt:

"Research this error: 'ECONNRESET during TLS handshake with upstream'. Find the most common causes in a Node.js/nginx setup and suggest fixes ranked by likelihood."

npx clawhub install web-search

Slack/Discord skill: post deploy updates and PR pings

The Slack and Discord skills let your agent send messages, post summaries, and ping specific users or channels. Most developers use this for deploy notifications, CI failure alerts, and PR approval reminders.

Best use case: Automated deploy summaries. After each production deploy, the agent posts a structured summary to #deployments — commit hash, deploy duration, error rate change, and whether tests passed. No manual Slack messages after each push.

Example prompt:

"Post a deploy summary to #deployments: include the commit message, deploy time, and current error rate from the monitoring dashboard."

npx clawhub install slack

Jira/Linear skill: auto-create issues from code TODOs

The Jira and Linear skills connect your agent to your issue tracker. They're most useful for closing the loop between code and tickets — turning // TODO comments into real issues, and updating ticket status as PRs merge.

Best use case: Run a weekly sweep across your codebase for TODO, FIXME, and HACK comments. The agent creates a Linear issue for each one, links it to the relevant file and line number, and sets priority based on the comment context.

Example prompt:

"Scan the src/ directory for TODO comments and create a Linear issue for each one. Include the file path, line number, and the full comment as the issue description."

npx clawhub install linear

Test Runner skill: run tests, summarize failures, suggest fixes

The Test Runner skill executes your test suite and returns a structured summary — not raw terminal output. It groups failures by module, explains what each failure means, and suggests what to fix.

Best use case: Pre-commit test runs with actionable output. Before pushing, the agent runs the relevant tests, identifies which failures are real regressions versus pre-existing issues, and suggests the minimal fix for each new failure.

Example prompt:

"Run the Jest test suite for the billing module. Summarize failures, identify which are new regressions versus pre-existing failures, and suggest fixes for the new ones."

npx clawhub install test-runner

A real developer workflow using 3 skills together

Here's what happens when these skills work as a system.

Developer relaxed and confident watching GitHub merges, test results, Slack notifications, and Jira tickets complete automaticallyBlink

You push a commit. The GitHub skill sees the push and summarizes the diff. The Code Review skill checks for logic errors and security patterns, posting inline comments. The Test Runner skill executes the affected test files and reports any new failures. The Slack skill posts a summary to #deployments with all three outputs combined.

You did nothing except write the code.

The full HEARTBEAT.md trigger chain that makes this work:

workflows:
  - name: on-push
    trigger: push
    branch: main
    steps:
      - skill: github
        action: summarize_commit
      - skill: code-review
        action: review_diff
      - skill: test-runner
        action: run_affected_tests
      - skill: slack
        action: post_summary
        channel: "#deployments"
        include: [github, code-review, test-runner]

Each step feeds its output to the next. The Slack message includes the commit summary, the review findings, and the test results — one structured post instead of four separate notifications.

Skills to avoid as a beginner

Terminal/Shell without permission scoping. The Terminal skill is powerful enough to cause real damage. An agent with unrestricted shell access that misinterprets an instruction can delete files, run unintended migrations, or modify configs. Always define allowed_paths and allowed_commands in the skill config before deploying.

Outdated ClawHub skills. The ClawHub registry has 5,400+ skills — and a non-trivial number haven't been updated in 18+ months. Check the skill's last_updated date and install count before adding it to a production agent. Skills that haven't been touched in a year often have outdated API calls that fail silently.

Skills that require API keys without secrets management. Some skills ask you to paste API keys directly into config files. Don't. Use environment variables or your agent platform's secrets manager. On Blink Claw, secrets are injected as environment variables automatically — your keys never touch config files.

How to write your own skill

Custom skills are plain markdown files. Create a SKILL.md with three sections: when to use this skill, what steps to follow, and what the output should look like.

The agent reads your skill file when a task matches the trigger you described. No code, no API registration — just a well-written markdown document that teaches the agent a specific workflow.

The OpenClaw documentation covers the skill authoring format in detail, including trigger syntax, output schemas, and how to chain skills together. Start with a simple single-step skill before building anything complex.

Frequently Asked Questions

How do I install OpenClaw skills?

Install from ClawHub via the web UI at clawhub.ai, or via terminal with npx clawhub install <skill-name>. Skills install to your agent's skills directory and activate on the next agent restart. Blink Claw supports skill installation from the UI without any CLI setup.

Are ClawHub skills safe to use?

Most are, but check the install count, last update date, and the skill's source before installing anything that requires broad permissions. Skills with 1,000+ installs and recent updates are generally reliable. Avoid skills that request unrestricted file system or shell access without a clear reason. On Blink Claw, skills run in an isolated environment — security patches are applied automatically without you managing the underlying infrastructure.

Can I create a skill for my own internal tools?

Yes. A custom skill is a markdown file you write and place in your agent's skills directory. It describes your internal tool, when to use it, and what steps to follow. No code required. Custom skills are particularly useful for internal APIs, proprietary tooling, or any workflow that doesn't have a ClawHub equivalent yet.

How many skills can one agent use?

There's no hard cap. Practically, most developers run 5–10 skills per agent before context overhead becomes a factor. The agent reads relevant skills at task time — not all skills simultaneously — so a larger skill library doesn't meaningfully slow it down. Blink Claw agents handle 10+ concurrent skills without configuration changes.

What's the difference between a skill and a tool?

A tool is a built-in capability the agent has natively — web search, code execution, file access. A skill is an installed extension that teaches the agent a specific workflow using those built-in tools. The GitHub skill, for example, uses the built-in HTTP tool and file tools to interact with the GitHub API in a structured, repeatable way. Skills are layered on top of tools, not replacements for them.

Start with the GitHub skill: npx clawhub install github — you'll have PR summaries running in under five minutes. Run OpenClaw without the hassle — Blink Claw handles everything from $22/mo.