The Bug Wasn't in the Code. It Was in the Skill.
· Jeff Pace
A team ships the same bug twice in one week.
Not the same code - the same bug.
Both times, an agent wrote a database migration the unsafe way, skipping a step that lives in the team's migration skill and nowhere else. Not in CI. Not in a linter. Not in a test. Nothing a build would catch.
Both developers swear they're using the migration skill.
They are.
They're just not using the same copy.
One is three weeks old. Another was locally edited by someone who thought they were improving it.
That's the part nobody really warns you about when teams start using agent skills.
The agents get better. The skills get better. And then, in teams that actually rely on them, they stop being shared artifacts and become local files.
The drift is invisible until it isn't
This shows up once skills stop being "examples" and start being part of how work actually ships.
Someone writes a good skill: how migrations work, how endpoints are named, the security checklist an agent runs before opening a PR.
It gets checked into Git. That feels like the source of truth.
Then people do what's easiest in practice: they copy it into .claude/, .cursor/, or whatever their tool reads locally.
Standardized, in theory.
But a repo is only the source of truth if it's the thing people are actually running from. Most teams don't have a real update loop for skills yet.
So over time:
Someone forgets to pull updates.
A new teammate never sets it up correctly.
Someone edits a local version mid-task and never syncs it back.
A few weeks later, there isn't one skill. There are several slightly different versions spread across machines, all still "valid" from the agent's perspective.
That's where things start to break.
Compliance (what actually gets executed)
The agent doesn't read your repository. It reads what's on disk.
So the standard isn't "what's in Git."
It's "what got copied last."
Consistency (what the team believes it standardized)
Two developers can think they're using the same migration or security workflow and still get different behavior from their agents.
Not because the skill failed - but because it quietly diverged.
Curation (how fixes spread)
When someone improves a skill, the question becomes: how does that change reach everyone?
If the answer is "tell people to pull the latest version," then you don't have a system.
You have coordination work.
And coordination work doesn't scale.
None of this shows up immediately. It shows up later - in code review, in production, in postmortems where someone realizes the rule existed the whole time, just not in the environment where the mistake happened.
Skills are infrastructure. Treat them like it.
We already solved this problem for code.
Nobody copies dependency code between projects anymore. You declare a version, and a package manager handles distribution.
Skills need the same treatment if they're going to behave like infrastructure.
The hard part isn't writing them. Most teams already can.
The hard part is making sure every agent runs the same version.
That's a distribution problem.
That's why we built SkillRepo
SkillRepo turns skills into versioned infrastructure.
You connect the GitHub repository where your skills already live. You keep editing them in Git the same way you do today. Every change becomes a versioned release.
From there, environments pull automatically.
So instead of relying on people to manually sync skills, every agent starts each session from the same current set of rules.
In teams using multiple tools - Claude Code, Cursor, Windsurf, Copilot - the same skill can be distributed consistently through the AgentSkills standard, without maintaining separate copies per tool.
Each skill carries version history, ownership, and an automated safety and quality grade. When a skill changes, there's one canonical update - and the next sync brings everyone forward together.
Fix it once. It spreads.
The plumbing matters
The skills themselves are usually not the problem.
The problem is assuming distribution is solved just because something lives in Git.
If your skills live in a repository people cloned once and only occasionally sync, drift is already happening.
It just hasn't shown up in the incident yet.
The bug wasn't caused by the agent.
It was caused by distribution.
→ Pull your team onto one library. One version. One source of truth.