Skills

How to Share Skills Across Your Team Securely

Sharing a skill across a team is easy; sharing it without leaking secrets or handing everyone the same powers is the part that needs a system.

Coworkers with laptops in a modern office meeting, working together to share Claude skills securely
Image: Pixabay / Pixabay Content License

Key Takeaways

  • Share project skills through version control or a plugin, never by pasting files into chat, so every teammate runs the same reviewed version.
  • Permissions are the real control: shared settings files set what a skill may do, and deny rules protect sensitive paths for everyone at once.
  • Secrets do not belong in a skill file. Keep keys and tokens in environment variables or your existing credential tools, and scan every skill for hardcoded values before sharing.
  • Review every skill before it reaches the team: read its instructions, scripts and hooks, test it on a safe copy, and name one owner for updates.

Introduction

A skill that works well for one person usually spreads by the fastest route available: someone pastes it into a chat channel, and by Friday five teammates run five slightly different copies.Sharing skills securely is not about slowing that spread down. It is about giving it one channel, one set of permissions, and one review step, so the skill that reaches the team is the skill you actually approved.
An agent skill is a folder built around a SKILL.md file: frontmatter with a name and a description, followed by instructions, plus optional scripts, references and templates. Sharing one is therefore a file-distribution question with a permissions question attached: who gets the folder, what may it do, and what sensitive material is inside it.

Three ways to share, and which one to pick

Project skills are the default for a small team. They live in the project repository, under a skills directory inside the project configuration folder, and are checked into version control alongside the code they describe. Everyone who pulls the repository gets the same version, and changes arrive as reviewed pull requests. For a procedure tied to one project, such as a client-report workflow, this is the right channel.
Personal skills live in the user’s own configuration directory and are not shared at all. If a skill is useful to the team but sits in a personal folder, move it into the project or a plugin instead of copying it around by hand.
Plugins are the channel for skills shared across many projects or an organisation. A plugin bundles skills with other components, and teammates install the plugin to receive them. This fits a company-wide skill, such as a brand-voice guide, that should reach every project without being copied into each repository. Whichever channel you choose, pick exactly one per skill. A skill that exists in both a repository and a chat transcript will drift, and drift is how an old, unreviewed version keeps running.

Permissions: the control that actually scales

A skill’s instructions are guidance, not enforcement. Permissions are what stop an agent from doing something it should not. Claude Code supports fine-grained permissions, and permission settings can be checked into version control so the whole team shares them, while each developer can still customise their own. That shared settings file is where team-wide rules belong.
Two kinds of rule matter most. Allow rules pre-approve safe, routine actions, such as running a project’s test command, so teammates are not interrupted by constant prompts. Deny rules are the guardrails: they can block reads and writes to sensitive paths, such as secrets directories and environment files, for everyone at once. A skill can also declare an allowed-tools list in its frontmatter, restricting it to read-only tools when the job needs no writes at all.
There is one honest limit to know. A repository-based setup has no per-person access control built in: anyone who clones the repository gets every skill in it. If one skill should only be available to senior staff, split it into a separate repository or plugin with narrower access, rather than relying on the repository to hide it.

Secrets: keep them out of the skill

The most common sharing mistake is also the easiest to make: a working skill that contains a real API key, token or password, committed to version control and cloned onto every laptop. Never put a secret in a SKILL.md file, a reference document, a script or an example. Examples should use placeholders, and the skill should read real values from environment variables or the credential tools the team already uses.
Before any skill is shared, search it for the obvious leaks: keys, tokens, passwords, private URLs and customer names in examples. Add secrets files and environment files to the repository ignore list so they cannot be committed by accident, and rotate any credential that was ever committed, even briefly. Removing a secret from the latest version does not remove it from repository history.

Review every skill before it reaches the team

Review is the step that makes the other controls trustworthy. Treat a new skill like a small code change, because that is what it is: instructions and code that will run with your teammates’ permissions. Read the full SKILL.md body, not just the description. Read every script it can run and every hook it registers, since both execute with user permissions. Check the allowed-tools list against what the job actually needs, and check the description: it must say both what the skill does and when to use it, or teammates will trigger it at the wrong time or never trigger it at all.
Then test it on a safe copy. Run it against sample data, not production data, and confirm it asks before any write or external action you did not expect. Record the review the way you would a code review: who reviewed it, when, and what changed. Finally, name one owner per skill, because a skill without an owner goes stale, and a stale skill looks authoritative while it is wrong.

A one-week rollout that stays secure

Start with one skill, not a library. Pick the procedure your team repeats most often, move it into the project repository or a plugin, and strip out any secrets. Set the shared permissions file with deny rules for secrets paths and an allowed-tools list that matches the job. Review it with one other person, test it on sample data, and announce it with its trigger description, so teammates know exactly when to use it. In week two, add the next skill the same way, and retire the chat-pasted copies. After a month, audit the library: delete skills nobody triggered and update owners.

FAQ

Can I just send a skill file to a teammate?
You can, but do not make it the habit. A file sent in chat has no version, no review record and no update path, so teammates quickly run different copies. Put the skill in version control or a plugin instead, and let teammates pull the reviewed version.
Do permissions in a shared settings file apply to everyone?
Yes, that is their purpose. Permission settings can be checked into version control and shared across the organisation, while individual developers can still add their own customisations. Use the shared file for team-wide guardrails such as deny rules on secrets paths.
What should I do if I find a secret in a shared skill?
Remove it from the skill, rotate the credential immediately, and check repository history, because deleting it from the latest version does not erase earlier copies. Then add the file pattern to the ignore list so it cannot be committed again.
Does a skill shared for Claude Code also appear in claude.ai?
No. Skills do not sync automatically between surfaces, so manage each one separately. A team rollout should state which surface the skill is for, rather than assuming it appears everywhere.

Conclusion

Secure skill sharing comes down to four habits: one distribution channel per skill, shared permissions with deny rules for sensitive paths, no secrets in skill files, and a real review with a named owner before anything reaches the team.

Sources

Claude Code documentation, Configure permissions (code.claude.com): fine-grained permissions; permission settings can be checked into version control and shared across an organisation, with per-developer customisation.

Claude Code documentation, Extend agents with skills and Add components to a plugin (code.claude.com): skills are SKILL.md files in their own directories; plugins bundle skills and other

components, and teammates receive them by installing the plugin.

Claude Code documentation, Orchestrate teams of Claude Code sessions (code.claude.com): teammates load skills from project and user settings; permission prompts surface to the session lead.

WebGool Tech Senior AI & Small Business Editor
Verified Contributor

Keep Reading

More in Skills

Explore all

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top