How to Share OpenClaw Skills Across a Team

When one developer installs a set of OpenClaw skills and configures them perfectly, that setup should not live only on their machine. Sharing skills across a team ensures every developer gets the same AI-assisted experience, new team members onboard faster, and coding standards are enforced consistently. This guide covers shared configurations, org-level registries, and onboarding workflows.

The Problem: Inconsistent Skill Setups

Without a shared approach, each developer on your team ends up with a different set of skills. One person installs the React skill from the Bazaar, another installs a different one, and a third skips skills entirely. The result is inconsistent agent behavior across the team, which defeats the purpose of having coding standards.

Approach 1: Commit the .openclaw Directory

The simplest way to share skills is to commit your project's .openclaw/ directory to version control. When any developer clones the repo, they get the same skills automatically.

Setting It Up

First, install the skills your team needs:

openclaw skill install typescript-strict
openclaw skill install react-best-practices
openclaw skill install security-audit

Verify the setup:

openclaw skill list

Then commit the entire .openclaw/ directory:

git add .openclaw/
git commit -m "Add shared OpenClaw skill configuration"

Directory Structure

After installation, your .openclaw/ directory looks like this:

.openclaw/
  config.toml
  skills/
    typescript-strict/
      skill.md
    react-best-practices/
      skill.md
    security-audit/
      skill.md

Every developer who clones the repo gets this exact configuration.

Handling Personal Overrides

Some developers may want additional skills for their own workflow. Use a local override file that is gitignored:

# .openclaw/config.local.toml (gitignored)

[skills]
additional = ["vim-workflow", "verbose-explanations"]

Add the override file to .gitignore:

echo ".openclaw/config.local.toml" >> .gitignore

This lets individuals customize without affecting the shared configuration.

Approach 2: Org-Level Skill Registry

For organizations with multiple repositories, maintaining skills per-repo creates duplication. An org-level skill registry solves this by providing a single source of truth.

Creating an Org Registry

Create a dedicated repository for your organization's skills:

mkdir org-openclaw-skills
cd org-openclaw-skills
git init

Structure it as a registry:

org-openclaw-skills/
  registry.toml
  skills/
    company-style/
      skill.md
    api-patterns/
      skill.md
    security-baseline/
      skill.md
    testing-standards/
      skill.md

Define the registry configuration:

# registry.toml

[registry]
name = "acme-corp-skills"
description = "Shared OpenClaw skills for Acme Corp"
version = "2.0.0"

[profiles.frontend]
skills = ["company-style", "api-patterns", "testing-standards"]

[profiles.backend]
skills = ["company-style", "api-patterns", "security-baseline"]

[profiles.fullstack]
skills = ["company-style", "api-patterns", "testing-standards", "security-baseline"]

Installing from an Org Registry

Developers install skills from your org registry instead of the public Bazaar:

# Add your org registry
openclaw registry add acme https://github.com/acme-corp/org-openclaw-skills

# Install a profile
openclaw skill install --registry acme --profile frontend

# Or install individual skills
openclaw skill install --registry acme company-style

Keeping the Registry Updated

When you update a skill in the registry, teams pull the latest:

openclaw skill update --registry acme

This checks for new versions of all installed org skills and updates them.

Approach 3: Team Skill Config File

For teams that want a middle ground between committing skills and running a full registry, use a shared config file that references skills by name and version:

# .openclaw/team-skills.toml

[team]
name = "platform-team"
updated = "2026-03-29"

[[skills]]
name = "typescript-strict"
version = "^2.0.0"
source = "bazaar"

[[skills]]
name = "react-best-practices"
version = "^1.5.0"
source = "bazaar"

[[skills]]
name = "company-style"
version = "^1.0.0"
source = "https://github.com/acme-corp/org-openclaw-skills"

Install all team skills with a single command:

openclaw skill install --from .openclaw/team-skills.toml

This fetches the specified versions from the specified sources and installs them locally.

Onboarding New Developers

A good onboarding experience makes the difference between a team that adopts skills and one that ignores them. Here is a step-by-step onboarding workflow.

Step 1: Document the Setup

Add a section to your project's README or contributing guide:

## AI Agent Setup

This project uses OpenClaw skills for consistent AI-assisted development.

### First-time setup
1. Install OpenClaw: \`curl -fsSL https://openclaw.dev/install.sh | bash\`
2. Install team skills: \`openclaw skill install --from .openclaw/team-skills.toml\`
3. Verify: \`openclaw skill list\`

### What the skills do
- **typescript-strict**: Enforces strict TypeScript patterns
- **react-best-practices**: React component and hook conventions
- **company-style**: Our internal code style and naming conventions

Step 2: Automate With a Setup Script

Create a setup script that handles everything:

#!/bin/bash
# scripts/setup-openclaw.sh

echo "Setting up OpenClaw skills for this project..."

# Check if OpenClaw is installed
if ! command -v openclaw &> /dev/null; then
  echo "Installing OpenClaw..."
  curl -fsSL https://openclaw.dev/install.sh | bash
fi

# Install team skills
openclaw skill install --from .openclaw/team-skills.toml

# Verify installation
echo ""
echo "Installed skills:"
openclaw skill list

echo ""
echo "OpenClaw setup complete. Run 'openclaw' to start."

Step 3: Validate in CI

Add a CI check that verifies all required skills are installed:

# .github/workflows/openclaw-validate.yml
name: Validate OpenClaw Config

on: [push]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Check skill config exists
        run: |
          if [ ! -f .openclaw/team-skills.toml ]; then
            echo "Error: .openclaw/team-skills.toml is missing"
            exit 1
          fi
      - name: Validate skill config
        run: openclaw skill validate --from .openclaw/team-skills.toml

Managing Skill Conflicts

When multiple team members propose different skills for the same purpose, establish a review process:

1. Propose via PR. Changes to the team skills config go through code review like any other code change.
2. Test before adopting. Have two or three developers trial a new skill for a week before adding it to the team config.
3. Document the decision. Add a comment in the config explaining why a specific skill was chosen over alternatives.

# We chose typescript-strict over typescript-relaxed because
# our codebase requires strict null checks and explicit return types.
[[skills]]
name = "typescript-strict"
version = "^2.0.0"
source = "bazaar"

Summary

Sharing OpenClaw skills across a team eliminates inconsistency, speeds up onboarding, and ensures your AI coding standards are followed by everyone. Start with the simplest approach that works for your team size: commit the .openclaw/ directory for small teams, use a config file for medium teams, or set up an org registry for large organizations. Find the skills your team needs in the OpenClaw Bazaar skills directory.

Browse the Skills Directory

Find the right skill for your workflow. The OpenClaw Bazaar skills directory has over 2,300 community-rated skills — searchable, sortable, and free to install.

Browse Skills →

Built a Skill? List It on the Bazaar

If you have built a skill that others would find useful, publish it on the Bazaar. Reach thousands of developers and get feedback from the community.

Learn how to publish →