Everyone Builds, Nothing Ships Unreviewed: How We Made AI Skill Sharing Safe at Cyera

How Cyera's 1,600 employees build and share AI skills with review, versioning, and least-privilege distribution.

Nov 16, 2026
Teilen

Almost 90% of Cyera employees use Claude every week thanks to the up-front investments we made in access governance and enablement. That rapid adoption also meant users quickly turned into authors.

When we rolled out Claude Cowork, it came with the context of the data and systems that each employee uses every day thanks to department-specific profiles based on identity groups. That meant the gap between "I do this task every week" and "I taught AI to do this task" disappeared. Within weeks, people across every department were building skills: reusable playbooks that teach AI to do a specific piece of work the way our company does it. A few examples:

  • Sales development encoded its top performers' outreach templates into a skill the whole team could use.
  • Legal built 20 playbooks that assess inbound vendor NDAs against our standard positions.
  • Marketing gave every marketer an agent that watches their project queue and catches missing assets before work goes out; one marketer gets 12 hours a week back.

Customer success, finance, and engineering followed. The skills were useful, and people wanted to share them. The problem was how to safely let hundreds of employees share AI capabilities with each other.

Why skills need review

We decided to treat a skill as code rather than as a document, and to review it with the same care as any push to a shared repository. Like code, a skill runs against real systems (the CRM, the data warehouse, the ticketing queue), its impact expands with every reuse, and it can be wrong, redundant, unpredictable, or overreaching.

As a data security company, we also knew where the alternative leads. When sharing through official channels is hard, people find more convenient workarounds. Prompts get pasted into direct messages, files fly around over email, and private libraries grow where nobody can see them. As our applied AI lead Joe Tustin put it in Anthropic's case study on our rollout, “saying no to AI is not a strategy.” But neither is saying yes without visibility.

Built-in sharing and its limits

Claude ships with skill sharing built in. A user can hand a skill to specific colleagues or to a whole group, admins can provision skills to everyone, and an organization can let people publish to a companywide library, with an optional owner-approval step. Admins can also bundle skills into plugins targeted at specific groups, and those group-targeted plugins became the distribution layer for everything else in this post.

When we built our skills workflow, the built-in sharing didn't cover what a skill contains. Nothing in the flow screened a skill for malicious content, checked whether it duplicated something a teammate already built, or kept a version history. Review sat with workspace owners rather than with the person who knows whether a sales skill is any good. Our risk profile demands all of that, so we kept the plugin distribution and built our own submission and approval workflow in front of it. The first version went live in April, and the current pipeline has been running since June.

Anthropic has since added new capabilities. The platform now offers duplicate hints for reviewers, version history, and custom reviewer roles, with a security scanning feature for skills and plugins in beta. Ours adds the checks specific to us: it lints every skill, checks it against our own data and policy rules, routes it to the AI lead for that team, and keeps Git as the system of record.

Version one: deliberately manual

We built the first version out of tools we already had, with no custom automation:

  1. Submit in chat. A skill walked the author through their submission and posted the finished SKILL.md file to a Slack channel.
  2. Review in Slack. AI admins monitored that channel, and the same skill logged every submission to a Notion database that tracked its status.
  3. Ship through Git. After approval, an admin uploaded the skill to our version-controlled repo, where a pull request with required approvals merged it into the right team's plugin. Users automatically picked up the skill the next time they opened their workspace.

It worked, and it taught us what to build next. There were three common failures with this approach:

  • Submissions arrived incomplete. New skills came with a file, but change requests came as a description of what to edit, and a description cannot be installed.
  • The central team became a bottleneck. Our AI team members were not the right people to judge whether a sales or finance skill is good, let alone review every team's submissions at scale.
  • The channel and repo drifted apart. The manual download-and-push handoff between the review Slack channel and the repo meant the system of record lived in two places that sometimes had subtle differences.

So we adjusted the process for submitting skills:

  • Require complete artifacts.
  • Push judgment to the people with domain and institutional context.
  • Make the system of record and the distribution channel the same thing.

The workflow we built

The second version turned that process into a pipeline. A submitter builds a skill in Claude and asks the tool to submit it when it's ready, making the process as easy as possible. Everything happens inside the conversation — no form or Git account required. The submitter gets back a submission ID and a link to a live view of the submission, where they can track it.

From there, every submission moves through three gates:

  1. Automated checks. A linter validates the skill's structure and metadata. An AI review pass evaluates quality, clarity, and fit, then runs overlap detection against the existing catalog to prevent duplicate work for submitters and reviewers. Security and governance checks screen the skill's instructions to understand how it handles data, what systems it reaches for, and whether it conflicts with company policy.
  2. A human decides. The AI leads closest to a team act as maintainers for that team's skill collection, and their review permissions come from the same identity provider groups that govern access to everything else at the company. Someone who knows sales judges a sales skill. Reviewers see the full skill, the submitter's note, the automated check results, and the overlap analysis in one place. Approval is one click. Every decision is logged, with denials requiring a written reason, and a revised skill comes back as a new submission.
  3. Distribution is automatic, versioned, and scoped. Approval opens and merges a pull request into our central skills repo. The maintainer's approval is the only human sign-off a skill needs; unlike version one, there's no second round of review on the pull request. And because nobody downloads or reuploads files by hand, the file that was reviewed is exactly the file that ships. Delivery itself works as it did in version one: most skills go to a single team's plugin and reach everyone on that team the next time they open their workspace. Skills useful to everyone live in a companywide plugin that every employee carries, so a skill from one team can become part of how the whole company works. Because Git is the backbone, we get version history, rollback, and diffs for free, and retiring a skill goes through the same review and log as shipping one.

Identity comes from the groups we already manage, change control from the code review tools we already trust, and distribution from the plugin mechanism our AI platform provides. The only new pieces are the submission tools inside the chat and the review surface for maintainers. That's why a small team could ship it and clear the security review quickly.

The catalog now holds 100 approved skills across 20 team plugins, a new approval reaches the whole team the same day with no manual work, and the teams shipping the most skills are the ones who trust the pipeline.

5 principles for anyone building this

Five principles carried the project, and we think they would transfer to any company whose employees have started building AI capabilities.

1. Treat skills as supply chain artifacts. The moment a skill can autonomously act on systems, it deserves review, versioning, provenance, and a rollback path. Classify what exists, know who can use it, and control how it changes. It's the discipline we bring to data, applied to AI capability.

2. Federate the judgment, centralize the rails. Give central platform teams the pipeline: the checks, the audit trail, and the distribution mechanics. Let maintainers who have the context deliver the verdict on whether a marketing skill is useful. This reduces bottlenecks and improves the quality of reviews.

3. Make the paved road the easiest road. If you want to avoid the shadow-AI pattern we caution our customers against, submitting through official channels has to be as easy as pasting a file into a chat thread. Ours is one sentence typed into Claude.

4. Start manual, then automate what's not working. Our Slack-and-Notion first version surfaced the real requirements in weeks at almost no cost. We automated only the steps that had failed.

5. Keep humans in the loop where it counts. Automated checks scale and AI review keeps improving, but the decision to put new behavior in front of a whole team remains a human call with a name attached. It was crucial to keep that accountability.

Where we’re going next

We’ve already built on this foundation to make it easier for employees to find the skills they need. A skill marketplace lets any employee browse every approved skill and import it into their own toolset, so people discover skills they didn't know to ask for and can see good examples before building their own. And specialist groups inside a department now have their own sub-team plugins with their own reviewers, so a skill reaches exactly the people who need it. Next, we're working on giving reviewers a way to test-drive a skill before approving it.

We're also planning brown-bag sessions across teams where builders walk through how they built skills and the impact they drove. The sessions will teach technique, but more importantly they’ll show people a colleague who has already made the leap. That's the fastest way to turn a user into a builder.

‍

Teilen