How to Set Up Shared Agent Skills for Your Development Team

Learn how to standardize your team's AI coding workflow with shared agent skills. Whether you have 3 developers or 30, this guide covers three proven methods to distribute, version, and maintain skills across your entire organization — so every team member gets the same Claude Code superpowers from day one.

Prerequisites

• Claude Code installed (v2.1+)
• A team Git repository
• Basic familiarity with agent skills and the terminal

Why Teams Need Shared Skills

When every developer writes their own prompts, you get inconsistency. One person's "refactor this" produces entirely different results from another's. Shared skills solve three problems:

Consistency. Every team member gets the same code review standards, the same debugging methodology, and the same commit message format. The skill file is the single source of truth.

# .claude/commands/code-review.md
# Every developer on your team runs the same review checklist
# — no more "I forgot to check for SQL injection"

Onboarding. A new hire clones the repo, and they instantly have every skill the team has built over the past year. No tribal knowledge lost.

git clone git@github.com:your-org/your-app.git
cd your-app
# Skills are already in .claude/commands/ — ready to use
claude

Code review standards. When the skill defines what "good code" looks like, PR reviews become objective. The AI applies the same standards to every diff.

If you're new to skills altogether, start with How to Create Your First Agent Skill before continuing here. For understanding how skills compare to MCP servers, see Skills vs MCP vs Rules.

Method 1: Git Repository

The simplest approach — commit skill files directly to your project repo.

Directory Structure

your-project/
├── .claude/
│   └── commands/
│       ├── code-review.md
│       ├── pr-description.md
│       ├── debug-production.md
│       ├── deploy-checklist.md
│       └── write-tests.md
├── src/
└── package.json

How It Works

Claude Code automatically discovers all .md files in .claude/commands/. When a team member clones the repo, the skills come with it.

# Create the skills directory
mkdir -p .claude/commands

# Create a team code review skill
cat > .claude/commands/code-review.md << 'EOF'
---
name: Team Code Review
description: Run our team's standard code review checklist
---

Review the staged changes against our team standards:

1. **Security**: No hardcoded secrets, SQL injection, XSS vectors
2. **Performance**: No N+1 queries, unnecessary re-renders, or unbounded loops
3. **Testing**: Every new function has at least one test
4. **Naming**: Variables and functions follow our conventions (camelCase for JS, snake_case for Python)
5. **Documentation**: Public APIs have JSDoc/docstrings

Output a markdown checklist with pass/fail for each item.
EOF

Version Control Benefits

# Track skill changes in your regular git workflow
git add .claude/commands/code-review.md
git commit -m "feat: add team code review skill with security checklist"

# Review skill changes in PRs just like code changes
git diff main -- .claude/commands/

Pros: Zero setup, version controlled, works offline, team reviews skill changes in PRs.

Cons: Skills are per-project. If your org has 20 repos, you need to sync skills across all of them.

Method 2: TokRepo Collections

TokRepo lets you create a collection of skills that your entire team can install with a single command. This is ideal for organizations with multiple repositories.

Step 1: Curate Your Team Collection

Browse TokRepo's skill library and pick the skills your team needs. You can also create custom skills and publish them.

Step 2: Create an Install Script

#!/bin/bash
# team-skills-install.sh
# Run this in any project to set up team skills

echo "Installing team skills from TokRepo..."

# Project management
tokrepo install e108cf5c-c34e-4d27-a694-66a693301e87  # GSD

# Debugging
tokrepo install 78ed006e-b022-4e92-bf65-df8b53afd2f4  # Systematic Debugging

# SEO (for frontend projects)
tokrepo install cb068086-1c7d-408e-90a1-c39cfc6ffe87  # Claude SEO

# Skill creation (for senior devs)
tokrepo install 0b7c0a41-97e1-4187-9cc5-4dc32d91a9cd  # Skill Creator

# Planning
tokrepo install 034be597-c361-45a2-b143-41cce0ec8ad8  # Planning

echo "Done. Run 'claude' to start using skills."

Step 3: Share With Your Team

# Add the install script to your org's shared repo
chmod +x team-skills-install.sh

# New team members run one command
./team-skills-install.sh

Pros: Centralized management, one-command install, skills auto-update, works across repos.

Cons: Requires internet access for initial install, team members need TokRepo CLI.

Method 3: Custom Skill Registry

For larger organizations that need full control, self-host a skill registry on your internal infrastructure.

Architecture

┌─────────────────┐     ┌──────────────────┐     ┌─────────────┐
│  Skill Authors   │────▶│  Internal Git     │────▶│  Developer   │
│  (Senior Devs)   │     │  Registry Repo    │     │  Machines    │
└─────────────────┘     └──────────────────┘     └─────────────┘
                              │
                              ▼
                        ┌──────────────────┐
                        │  CI/CD Pipeline   │
                        │  (validate &      │
                        │   distribute)     │
                        └──────────────────┘

Implementation

# internal-skill-registry/
# ├── skills/
# │   ├── code-review.md
# │   ├── deploy-checklist.md
# │   └── incident-response.md
# ├── validate.sh          # Lint skill frontmatter
# ├── distribute.sh        # Push to all project repos
# └── README.md

# validate.sh — ensure every skill has required frontmatter
#!/bin/bash
for skill in skills/*.md; do
  if ! grep -q "^name:" "$skill"; then
    echo "ERROR: $skill missing 'name' field"
    exit 1
  fi
done
echo "All skills valid."

# distribute.sh — sync skills to all team repos
#!/bin/bash
REPOS=("app-frontend" "app-backend" "app-mobile" "shared-lib")

for repo in "${REPOS[@]}"; do
  echo "Syncing skills to $repo..."
  cp -r skills/ "../$repo/.claude/commands/"
done

Pros: Full control, works behind firewalls, custom validation, audit trail.

Cons: Maintenance overhead, need to build tooling, no community skills.

Recommended Team Skill Stack

Based on real team deployments, here are five skills every development team should install:

1. Get Shit Done (GSD)

The project management backbone. Breaks work into milestones and phases with persistent tracking.

tokrepo install e108cf5c-c34e-4d27-a694-66a693301e87

View on TokRepo →

2. Systematic Debugging

Structured 4-phase debugging: reproduce, isolate, diagnose, fix. Prevents random trial-and-error.

tokrepo install 78ed006e-b022-4e92-bf65-df8b53afd2f4

View on TokRepo →

3. Claude SEO

Comprehensive SEO audits — keyword research, on-page analysis, technical checks.

tokrepo install cb068086-1c7d-408e-90a1-c39cfc6ffe87

View on TokRepo →

4. Skill Creator

Meta-skill for building team-specific skills. Senior devs use this to package tribal knowledge.

tokrepo install 0b7c0a41-97e1-4187-9cc5-4dc32d91a9cd

View on TokRepo →

5. Planning with Files

Persistent planning that survives across Claude Code sessions. Essential for multi-day tasks.

tokrepo install 034be597-c361-45a2-b143-41cce0ec8ad8

View on TokRepo →

Case Study: 5-Person Team Setup

Here's how a real 5-person startup team standardized their Claude Code workflow in one afternoon.

The Team

Step 1: Tech Lead Creates the Skill Set (30 min)

Sarah identified the team's top 5 pain points and mapped each to a skill:

# Sarah's laptop
mkdir -p .claude/commands

# 1. Install community skills
tokrepo install e108cf5c-c34e-4d27-a694-66a693301e87  # GSD
tokrepo install 78ed006e-b022-4e92-bf65-df8b53afd2f4  # Systematic Debugging
tokrepo install 034be597-c361-45a2-b143-41cce0ec8ad8  # Planning

# 2. Create team-specific skills
cat > .claude/commands/our-pr-review.md << 'EOF'
---
name: PR Review (Team Standard)
description: Review code against our team's 12-point checklist
---
Review the current diff. Check for:
1. No console.log in production code
2. All API endpoints have rate limiting
3. Database queries use parameterized statements
4. React components have error boundaries
5. Go functions return errors (no panic)
...
EOF

Step 2: Team Installs Skills (5 min each)

# Each team member runs:
git pull origin main
# Skills are already in .claude/commands/ — done.

Step 3: Measure the Impact (2 weeks later)

The junior developer (Tom) benefited the most — the debugging skill taught him a systematic approach he hadn't learned yet, and the PR review skill caught issues before senior devs had to review.

FAQ

How do I handle skill conflicts between team members?

Use Git's normal merge workflow. If two people edit the same skill, resolve the conflict in a PR review. For community skills installed via TokRepo, pin to a specific version by keeping a copy in .claude/commands/ rather than relying on auto-updates.

Can I restrict which skills team members can install?

Not natively. However, with Method 3 (custom registry), you can implement an allowlist. For Method 1 (Git repo), use a pre-commit hook that rejects unknown .md files in .claude/commands/:

# .husky/pre-commit
ALLOWED_SKILLS="code-review.md pr-description.md debug-production.md"
for file in $(git diff --cached --name-only -- .claude/commands/); do
  basename=$(basename "$file")
  if ! echo "$ALLOWED_SKILLS" | grep -q "$basename"; then
    echo "ERROR: Unapproved skill: $basename"
    exit 1
  fi
done

Do skills work the same for every team member?

Yes, given the same skill file and the same Claude Code version. The skill defines the behavior; the model follows it deterministically. Minor variation can occur based on Claude model version, but the structure and checklist items remain consistent.

Next Steps

• How to Create Your First Agent Skill — build custom skills for your team
• 15 Best Claude Code Skills — browse our curated top picks
• Skills vs MCP vs Rules — understand which extension type fits team workflows
• Browse TokRepo Collections — discover 500+ ready-to-install skills