- Governança de IA
- Inteligência Artificial
- Segurança da Informação
- Arquitetura de Software
- Automação
- Claude Code
Skills Hub
AI Skills Governance for Non-Developers
A Claude Code or Codex skill looks harmless: it's a folder with an instructions file. But that folder often also ships scripts that run on the user's machine. As long as it lives only on your computer, that's fine. Once it starts landing on the computers of 35 people across 7 teams, it becomes software, with every question software brings: who gets it, which version, and who guarantees nobody changed what was approved. In AI Governance in Practice I promised to show how some skills became internal systems at InBot. I'll start with what holds all of them up: the Skills Hub, and the AI skills governance running underneath it without non-developers ever needing to know it exists.
When a Skill Leaves Your Machine, It Becomes Software
Anthropic itself is blunt about this. In the Agent Skills documentation, the advice is to use skills only from trusted sources and to treat installing a skill like installing software, because a malicious skill can run code that has nothing to do with its stated purpose.
This isn't excessive caution. In February 2026, Snyk analyzed 3,984 skills published on an open marketplace and found 534 with critical security issues and 76 confirmed malicious. And the postmark-mcp package shows how it plays out: 15 clean versions building trust, until in the next release a single line started sending a hidden copy of every email to the attacker.
How we started (and why we couldn't keep going that way)
At InBot, the skills were good from day one. What surrounded them wasn't. When the AI area started delivering to the whole company, the pace was intense: lots of tasks in the sprint and little time to build the software side properly.
The hub we used back then wasn't built by our team. It was a prototype created earlier to validate the idea, and it did that job well: it proved that distributing skills to the whole team worked. But the prototype stayed in use. It had no authentication, and uploading content required only an admin password. Anyone who found that password could publish something malicious.
Updating the machines had the same profile. Each team had its own installer, which left the team identifier and a read-only credential for the skills repository on the person's computer. Content was audited before reaching the machines, but the mechanism was fragile.
When the delivery pace slowed down, the development team, the most technical team in the company, raised the security risks, and they were absolutely right. The board made a decision I consider the most mature point of this story: slow down the delivery of skills, automations and platforms to fix the foundation. On October 3 we did what we internally call the "big bang": in a single day, the backend, the login, the signing and the review flow all changed at once.
Before getting into how it works, one important definition: when I say "Skills Hub", I don't mean just a website. The Hub is the web app, the backend and the skills themselves that talk to it, like the one that installs, the one that logs you in and the one that publishes.
Who Gets What: SSO, Groups and "See = Receive"
The first question for any distribution system is who gets what. The answer was to take that decision away from any shared password and hand it to SSO (corporate single sign-on), the same login people already use for the company's other systems.
In the terminal, login uses the Device Authorization Grant: the script shows a code, the person opens the browser, signs in with their company account, and that's it. With PKCE, nobody who intercepts that flow can reuse the code. The identity provider is Keycloak, which already offered the device flow, offline sessions and groups out of the box.
Groups per team, and what's out of reach doesn't exist
Each team is a group: sales, development, marketing, planning, projects, QA and UX. There are also groups for staging, for editors and for administration. That leads to a simple rule I call "see = receive": the same function decides what the sync downloads to your machine and what the Hub shows you. There's no screen showing one thing while an installer delivers another.
And if you ask for a skill that isn't your team's, the answer isn't "access denied". It's "doesn't exist". It looks like a detail, but it stops anyone from discovering, by trial and error, which skills other teams have. On the other side, revoking someone's access takes effect fast. Login issues two tokens: an access token, which lasts only 5 minutes, and a refresh token, which is used to request a new access token and expires after 2 days of inactivity. When a person's access is revoked, the refresh token may still be valid, but it becomes useless: it can no longer get a new access token, and what they had stops working within 5 minutes at most. If you've read the post on ReBAC authorization, you'll recognize the idea: access is a relationship, and relationships must be quick to undo.
The source of truth is the repository, not the database
There's one design decision that shapes everything that follows: the files are the source of truth. A skill's version and who has access to it are recorded in the skill itself, inside the repository. The backend reads that, but it doesn't own it.
In practice, if tomorrow we switch platforms, leave the Hub or even lose the backend data, we still know exactly how everything is organized, and Git history gives us traceability for every change. Anthropic's Skills for enterprise guidance goes the same way: use version control as the source of truth for skills.
What Arrives Is What Was Approved: Ed25519 Signatures and Human Review
Now the scenario that changed how I think about this. Imagine someone gets access to the company's GitHub, by any means, and pushes a skill with a malicious script. In a naive model, the sync does exactly its job: it delivers that script to all 35 machines the next morning.
This isn't paranoia; it's the pattern of the biggest recent software supply chain incidents. In xz utils, in 2024, versions 5.6.0 and 5.6.1 shipped with a backdoor straight from the official repository. In tj-actions/changed-files, in 2025, a compromised GitHub Action exposed the secrets of everyone running it. And the Shai-Hulud worm compromised more than 500 npm packages, published under the developers' own names. In every case, the trusted source was what delivered the malicious code.
Signing: the machine only accepts what a human approved
The answer was to separate "being in the repository" from "being approved". Every released version is digitally signed, and the user's machine refuses to install anything that doesn't check out.
- What gets signed: the install, sync and login scripts, in their Linux/macOS and Windows versions, plus a list with the hash (the fingerprint) of every released skill. If a single file in the skill changes, the hash changes and the signature no longer matches.
- How: with plain ssh-keygen, which has been able to sign and verify files since OpenSSH 8.1, using a password-protected Ed25519 key. We chose SSH because it's already installed everywhere; even GitHub's documentation says SSH signatures are the simplest to generate. And Ed25519 is fast, has small keys and signatures, and doesn't depend on generating a random number for each signature.
- Where it's checked: on the user's machine, on the server and even in the browser. When someone downloads the installer from the Hub page, the browser itself verifies the signature with WebCrypto, a feature that only reached all major browsers in 2025, with Chrome 137. To deliver a fake installer, someone would have to break into the server and the Hub at the same time.
With that, the compromised-GitHub scenario changes completely. The change lands in the repository, but doesn't reach a single machine, because nobody signed it. And at the same moment, an email goes out to the AI team and the board, warning that something is wrong.
AI prepares, a human signs
Every publication becomes a review pull request, and the AI team approves it with a script that shows exactly what will be released, asks for the key password once, merges and signs. The SLSA framework sums up why: a review by a second person could have caught the unauthorized change. Anthropic says the same thing, in so many words, in its enterprise skills guide:
"Skill authors should not be their own reviewers."
In other words: whoever writes the skill shouldn't be the one who reviews it.
And here's a rule I won't bend: an AI agent never signs or approves. AI does almost the whole path (preview, form, PR, ClickUp card), but the signature always comes from a person.
First, for accountability: someone has to answer for what lands on the whole team's computers. Second, for defense: if an agent could sign, a malicious instruction hidden in a file could convince it to release something.
This didn't become a bottleneck, precisely because the review arrives ready: diff, completed form and tests already run. If you want to know why I like PRs with protection rules on the main branch so much, I wrote about it in Git Flow to GitHub Flow.
Non-Developers Don't Even Notice: Single Login, Daily Sync and Staging Channels
None of this would matter if it weighed on the people using it. Security that gets in the way becomes a workaround, and an AI workaround has a name: shadow AI, using AI outside any control. According to Gartner, as reported by Infosecurity Magazine, 69% of organizations already suspect this kind of use, and more than 40% are expected to have an incident tied to it by 2030. So the rule was clear: the cost of rigor stays with the builders, not the users.
For the people using it, the experience is this:
- One install, with login. After that, they don't think about it anymore.
- Updates on their own. The sync runs every morning and also when the person opens Claude Code or Codex, if it hasn't run yet. It only downloads what changed.
- Works wherever they are: Claude Code and Codex, on Linux, macOS and Windows.
- Staging and production channels. People in the testing group get the staging version by default, and can ask for the production one for a specific skill.
Where the complexity showed up: in the publishers
For the team in general, the system is still simple. The complexity showed up for the leads who publish skills, and it isn't technical: there are many options and a flow with rules. Since the files are the source of truth, publishing a skill means touching its files, and many leads aren't technical.
The fix was a skill. The same one that updates skills on the machine learned to publish: the person asks in plain language, the skill builds the preview with the diff (what's new, what changed, what was removed), helps fill out a 7-field form (problem, who uses it, input, output, success criteria, risks and origin) and sends it for review. The answer comes within 2 business days. It's AI automating its own governance.
Testing a skill like a real user
Before a skill reaches review, it goes through a test suite run by another skill, testar-skill. It builds 10 scenarios (5 ideal, 3 ambiguous and 2 extreme), varying how much information the person gives, the quality of the documents and the tone of the message. The expected answer for each scenario is written before running, in the same spirit as what I described in my journey with TDD.
Then testar-skill fires off subagents in parallel, each with a clean context and talking like a real user, without knowing it's a test. If the skill under test asks a question, the "user" answers in the same tone; if it gets nowhere in 5 rounds, the result is "doesn't converge". Any external action is deferred, and the person's files are protected during the suite. There are already more than 70 skill test reports on file.
Measuring usage, showing exactly what leaves the machine
The last piece came from outside. At Lovable Day, I heard from another company doing work similar to ours that they measure what actually gets used. We were already measuring installs and updates, but not the use of the skills themselves. The challenge was figuring out how to measure it without intruding on anyone's work.
The answer was Claude Code and Codex hooks that record only three things: which skill was used, on which day and in how many sessions. Prompts, responses, conversations, file contents or names, commands and third-party skills are never collected. This follows the necessity and transparency principles of Brazil's data protection law, the LGPD: collect the minimum for the purpose and make clear what is collected.
The transparency is concrete. People see a notice the first time and have a command that shows exactly what leaves their machine, the way VS Code and Homebrew do with their telemetry. With this data, we'll retire the skills nobody uses and prioritize improvements to the ones that run the most, which is exactly what Anthropic recommends for skills in companies.
What Went Wrong: the Cost of Rigor Stays with the Builders
Supporting two AI tools on three operating systems has a price, and it shows up in the bugs. Four of them are worth telling.
- The em dash that became a "network error". Windows PowerShell 5.1 reads scripts without a BOM (a marker at the start of the file indicating its encoding) using the legacy "ANSI" code page, as Microsoft's documentation explains. A single em dash (the character
U+2014) in a comment broke parsing of the whole script, and the error reached the user as a "network error". In other words, the bug even lied about its own cause. - macOS's old bash. macOS still ships bash 3.2, and the most accepted explanation is licensing: newer versions are GPLv3. Associative arrays only exist from bash 4.0 on, and the sync used one. Result: on the Mac, it broke silently.
- The false "unsigned version" alarm. Signing happens seconds after the merge, and sometimes the backend lost track of that commit. That fired the alert email to everyone. The fix was a 30-minute grace period and re-reading the branch before alerting. An alarm that goes off for nothing teaches people to ignore alarms.
- The keyring that signed on its own. On Linux, the session keyring unlocked the signing key for any process. In practice, any program running in my session could sign without asking for the password. Signing moved to an isolated SSH agent, used only for that.
All of them reinforce the same lesson: rigor has a cost, and that cost has to stay with the builders.
Where to Start with Skills Governance on Your Team
In about four months, from the first commit in June to the big bang in October, there were 382 commits and 186 releases. Today there are 55 skills in production reaching 7 teams, all signed, reviewed and tested. I share these numbers with the same care as in the previous post: they're the result of a team that agreed to slow down deliveries to fix the foundation, and of leads who publish skills even without being technical.
You don't need all of this to get started. If you share skills or prompts with your team, the minimum viable software is this:
- Version it. Skills in a repository, with history. If nobody knows which version is running on whose machine, you don't have one skill, you have several.
- Have someone review. Whoever writes doesn't approve. It can be a PR with a simple rule on the main branch.
- Know who gets what. Even if it's just one folder per team, at first.
- Leave signing for later, but not for never. It comes in once skills start reaching many machines, and the ssh-keygen you already have does the job.
And, from day one, simplicity for the users. If I have to choose between one more rule for me and one more step for the user, I'll take the extra rule for me.
Conclusion
A skill is software the moment it leaves your machine. Treating it that way means answering three questions: who gets it, which version, and who guarantees nobody changed what was approved. In the Skills Hub, the answers are SSO with groups, the files as the source of truth, and a signature only a human makes.
What makes this workable is what users don't see. People log in once and that's it; the complexity stays with the team that builds, and even the hard part of publishing became a conversation with a skill. If you're starting to share skills with your team, begin with versioning and review, and ask at every decision: does this weigh on me or on the user? In the next post in this series, I want to show how one of these skills became an entire system.
References
- Anthropic. "Agent Skills". Claude Docs.
- Anthropic. "Skills for enterprise". Claude Docs.
- Beurer-Kellner, L. et al. "ToxicSkills" study. Snyk, 2026.
- Lyons, Jessica. "One line of malicious npm code led to massive Postmark email heist". The Register, 2025.
- CISA. "Reported Supply Chain Compromise Affecting XZ Utils Data Compression Library, CVE-2024-3094", 2024.
- Freund, Andres. "backdoor in upstream xz/liblzma leading to ssh server compromise". oss-security, 2024.
- CISA. "Supply Chain Compromise of Third-Party tj-actions/changed-files (CVE-2025-30066) and reviewdog/action-setup@v1", 2025.
- CISA. "Widespread Supply Chain Compromise Impacting npm Ecosystem", 2025.
- SLSA. "Supply chain threats", v1.2.
- OpenBSD. "ssh-keygen(1)".
- GitHub Docs. "About commit signature verification".
- Josefsson, S.; Liusvaara, I. "RFC 8032: Edwards-Curve Digital Signature Algorithm (EdDSA)". IETF, 2017.
- Google. "Chrome 137 release notes", 2025.
- MDN. "SubtleCrypto: verify() method".
- Denniss, W. et al. "RFC 8628: OAuth 2.0 Device Authorization Grant", 2019.
- Sakimura, N. et al. "RFC 7636: Proof Key for Code Exchange by OAuth Public Clients", 2015.
- Keycloak. "Server Administration Guide".
- Brazil. "Law No. 13,709/2018 (LGPD)".
- Visual Studio Code Docs. "Telemetry".
- Homebrew. "Anonymous Analytics".
- Microsoft Learn. "about_Character_Encoding".
- Ramey, Chet. "Bash NEWS".
- The Next Web. "Why does macOS Catalina use Zsh instead of Bash? Licensing", 2019.
- Infosecurity Magazine. "Gartner: 40% of Firms to Be Hit By Shadow AI Security Incidents", 2025.
- Mierzwa, Matheus. "Governança de IA na Prática".
- Mierzwa, Matheus. "Construindo um Sistema de Autorização ReBAC".
- Mierzwa, Matheus. "Git Flow para GitHub Flow".
- Mierzwa, Matheus. "Minha Jornada com TDD".