# OpenClaw Agent Skills: Shared Workflow Library for Claude Code, Codex, and Other Coding Agents

> OpenClaw Agent Skills is an MIT-licensed library of eight workflow skills for coding agents, providing a single source for common tasks such as code review closeout, remote validation, and session viewing. It is aimed at teams and individual developers who want to share agent workflow definitions across multiple repositories without duplicating long skill files.

**openclaw/agent-skills** — Useful skills for agents and claws.

- Repository: https://github.com/openclaw/agent-skills
- Stars: 1,101 · Forks: 105
- Language: Python
- License: MIT
- Published: 2026-09-18 · Updated: 2026-09-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/openclaw-agent-skills

## What OpenClaw Agent Skills Addresses and Who It Serves

When a team runs coding agents across many repositories, common workflows like code review closeout or remote validation tend to get copied by hand into every repo's CLAUDE.md or AGENTS.md. Each copy drifts independently. OpenClaw Agent Skills solves this by making one repository the canonical source for shared skills and providing an install script that links or copies them into any agent environment.

The project targets developers and teams using Claude Code, OpenAI Codex, or compatible coding agents who want to define a workflow once and reuse it everywhere. The README states the goal directly: write a workflow once, reuse it everywhere, and avoid hand-copying long SKILL.md files across every repo. Repo-specific product skills are expected to stay in the repo they describe; this repository holds only skills general enough to be shared.

## The Eight Included Skills and Their Purposes

The library includes eight skills, each living in its own directory under `skills/`:

- `agent-transcript`: local-only, redacted PR and issue transcript provenance.
- `autoreview`: structured closeout and code-review workflow with a helper script.
- `behavior-validator`: source-blind validation of user-visible behaviour against a contract.
- `beam`: self-contained, authenticated, redacted publication of local coding sessions to a read-only OpenClaw catalog.
- `crabbox`: Crabbox or Testbox remote validation workflow for broad or CI-parity proof.
- `handoff`: path-free prompt handoff workflow for delegating a task to another agent.
- `readme-standard`: house README structure, badge row, tone, and verification gates for steipete/openclaw repositories.
- `session-viewer`: local searchable HTML viewer for agent session JSONL.

Each skill contains a `SKILL.md` file, and helper scripts live inside that skill's `scripts/` directory. The repository's VISION.md documents catalog boundaries and admission principles for determining which skills belong here versus in a product-specific repository.

## Installing Agent Skills in Claude Code or Codex

The repository provides an `install-skills` script that handles discovery, dry runs, selective installs, and target directory overrides. Start by cloning the repository:

```sh
git clone https://github.com/openclaw/agent-skills.git
cd agent-skills
```

List available skills before installing:

```sh
scripts/install-skills --list
```

Preview the install without changing any files:

```sh
scripts/install-skills --dry-run
```

Install all skills into the default agent skill directory:

```sh
scripts/install-skills
```

Install only the skills you need:

```sh
scripts/install-skills autoreview crabbox
```

For Claude Code, symlink the repository into `~/.claude/skills`:

```sh
mkdir -p ~/.claude
ln -sfn "$(pwd)/skills" ~/.claude/skills
```

For Codex, the target is `~/.codex/skills`:

```sh
mkdir -p ~/.codex/skills
ln -sfn "$(pwd)/skills" ~/.codex/skills/agent-skills
```

If your `~/.claude/skills` directory already points at another shared folder, add individual symlinks inside it instead:

```sh
ln -sfn "$(pwd)/skills/autoreview" /path/to/shared-skills/autoreview
ln -sfn "$(pwd)/skills/crabbox" /path/to/shared-skills/crabbox
```

The README recommends symlinks for local development because changes in the checkout take effect immediately. Copies work better for portable or locked-down setups. The install script checks every selected destination before changing files, including when `--force` or `--dry-run` is specified, and skips any attempt to install directly over the source directory.

## Vendoring Skills in Zero-Setup Repositories

Some flagship repositories need to work for contributors who only cloned that repo and never installed shared skills. For those cases, the README describes a vendored snapshot pattern: the repo stores a generated copy under `.agents/skills/<name>` rather than requiring a separate install.

The README is explicit that a vendored snapshot is a distribution artifact, not the source of truth. The correct process is to edit skills in this repository first and then sync snapshots downstream after review. Keeping downstream copies small in number and adding provenance and drift checks when vendoring is strongly advised.

The README singles out `autoreview` as a good candidate for vendoring in flagship repos because review closeout is part of the contribution workflow. Large operational skills should be vendored only when the repo genuinely needs them without setup.

## Validation, Development Checks, and CI

The repository uses Python 3.14 and Node.js 26 for development checks, matching CI. To run the full check suite, install the development dependencies and run the shared check command:

```sh
python3 -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements-dev.txt
npm ci --ignore-scripts
python scripts/check-skills
```

The check command runs frontmatter validation, syntax checks, all Python and Node tests, and `npm run typecheck` for the session viewer. The README clarifies that Node packages are development-only; installed skills do not need `npm install`. The macOS CI job installs a pinned Codex CLI to exercise native sandbox access controls.

For a quick frontmatter-only check without running tests, use:

```sh
scripts/validate-skills
```

This checks every `skills/*/SKILL.md` for YAML frontmatter and required `name` and `description` strings. The frontmatter must be a mapping enclosed by standalone `---` lines.

The README also warns that session exports can contain sensitive conversation data and that `session-viewer` HTML output should be treated as local and private unless separately redacted and reviewed.

## Design Boundaries and Cases Where This Repository Does Not Apply

OpenClaw Agent Skills is a shared collection, not a general agent skill framework. Skills that belong to a specific product stay in that product's repository. The README gives a concrete example: a usage skill for the `acpx` tool belongs in `openclaw/acpx`, while a general review helper belongs here.

The library does not support every agent environment. The README documents Claude Code and Codex paths directly. Other agent environments may need manual configuration or individual symlinks, because the installer targets specific well-known skill directories.

The session-viewer skill generates local HTML from JSONL session files. If your sessions contain private information, the generated HTML is sensitive output that requires its own access controls before sharing. The README warns about this explicitly and recommends treating the output as private unless it has been redacted and reviewed.

Vendored downstream snapshots should not be updated by hand. The README states the update sequence: edit in this repository, then sync snapshots downstream after review. Editing vendored copies directly breaks provenance and creates drift that is difficult to detect.

## OpenClaw Agent Skills vs. Inline Skill Definitions

The most common alternative to a shared skill library is defining workflows inline in each repository's CLAUDE.md or AGENTS.md. That approach works well for small teams with one or two repositories. As the number of repositories grows, duplicated skill files diverge because each change must be applied everywhere by hand.

OpenClaw Agent Skills centralises the definitions. Changes to autoreview or crabbox propagate to every environment that installed via symlink the next time the repository is pulled. For vendored copies, propagation requires an explicit sync step, but the intent is the same.

The trade-off is setup cost. A new contributor must clone this repository and run the install script before agent workflows are available. The README addresses this directly by recommending that flagship repos vendor autoreview as a zero-setup snapshot, so the most important workflow is always available without extra steps.

The repository reached v0.2.0 on 2026-09-24 and v0.1.0 on 2026-09-22, with the last push on 2026-09-27. The release cadence so far is rapid.

## Conclusion

OpenClaw Agent Skills suits any team running Claude Code or Codex workflows across multiple repositories and tired of maintaining parallel copies of the same skill files. The install script handles both symlinks for local development and copies for locked-down environments, and the validate-skills script catches frontmatter errors before they break an agent session. Teams that need only one or two skills can install them selectively. Verify that your agent environment resolves the installed skill directory, because the README documents Claude Code and Codex paths explicitly but notes that other setups may need individual symlinks inside an existing shared skills folder.

## FAQ

### How do I use agent skills in Claude Code?

Clone the openclaw/agent-skills repository and run `ln -sfn "$(pwd)/skills" ~/.claude/skills` to symlink all skills into Claude Code's skill directory. You can also use `scripts/install-skills` to install only selected skills or copy them rather than symlink.

### How do I use agent skills in Codex?

Symlink the repository into `~/.codex/skills` with `ln -sfn "$(pwd)/skills" ~/.codex/skills/agent-skills` after cloning. The README also documents adding individual skill symlinks inside an existing shared skills folder if that directory is already in use.

### How do I install agent skills in Claude Code?

After cloning the repository, either run `scripts/install-skills` to install into the default directory, or use the symlink command `ln -sfn "$(pwd)/skills" ~/.claude/skills`. Run `scripts/install-skills --dry-run` first to preview what would change.

## Sources

- [Issues](https://github.com/openclaw/agent-skills/issues)
- [License: MIT](https://github.com/openclaw/agent-skills/blob/main/LICENSE)
- [openclaw/agent-skills on GitHub](https://github.com/openclaw/agent-skills)
- [README](https://github.com/openclaw/agent-skills/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openclaw-agent-skills