Over the past two years we’ve constantly talked about models.
More context.
More tokens.
More benchmarks.
More reasoning capacity.
But one of the most interesting features of Claude Code has nothing to do with the model.
It has to do with a folder.
.claude/skills
The latest Claude Code release introduced automatic plugin loading from that location, added the claude plugin init <name> command to generate scaffolding, and improved the experience around /plugin.
It might seem like a minor change.
It’s not.
Because it points to a much deeper transition: Claude Code is evolving from a generalist agent into an extensible workflow platform.
And that could change how teams organize operational knowledge within their repositories.
The Problem with Generalist Agents
Current models know a lot of things.
But they rarely know how your team specifically works.
They don’t know:
- Your deployment flow.
- Your architecture conventions.
- Your testing rules.
- Your security procedures.
- Your documentation standards.
- Your review practices.
Every time we open a new session we have to explain part of that context again.
Even with memory, indexed repositories, and enormous context windows, there’s still an important difference between general knowledge and operational knowledge.
Agents understand code.
Teams understand processes.
And that gap is precisely where skills come in.
What is a Skill Really?
The simplest way to understand it is to think of a skill as a specialized capability packaged within the repository.
It’s not simply a prompt.
It’s not just documentation.
It’s not only automation.
It’s a combination of:
- Context.
- Instructions.
- Tools.
- Procedures.
- Specific knowledge.
All versioned alongside the code.
For example:
.claude/
└── skills/
├── security-review/
├── release-checklist/
├── migration-validator/
├── api-documentation/
└── incident-response/
Each skill can teach the agent how to execute a specific task following that project’s rules.
From Prompt Engineering to Workflow Engineering
For a long time the conversation centered on prompts.
The question was:
What’s the best prompt?
Now the question is starting to change:
What’s the best workflow?
That shift is important.
Because prompts live in conversations.
Workflows live in repositories.
And repositories are where teams collaborate.
A well-designed skill can capture years of operational experience and make it available to any developer working on the project.
The New Invisible Infrastructure
The best skills probably won’t be the most complex.
They’ll be the most repetitive.
Let’s think about tasks that happen constantly:
Security Review
/plugin security-review
The agent:
- Searches for exposed secrets.
- Reviews permissions.
- Verifies dependencies.
- Evaluates critical configurations.
- Generates a standardized report.
Release Validation
/plugin release-checklist
The agent:
- Runs checks.
- Reviews changelogs.
- Verifies migrations.
- Validates documentation.
- Generates a risk summary.
Architectural Audit
/plugin architecture-review
The agent:
- Detects pattern violations.
- Reviews dependencies between modules.
- Evaluates context boundaries.
- Suggests improvements.
None of these tasks depends exclusively on the model.
They depend mainly on the process.
What’s Interesting Isn’t the Automation
It’s the Portability.
Until now much of the operational knowledge lives in scattered places:
- Wikis.
- Notion.
- Confluence.
- Internal documents.
- Slack messages.
- Tribal knowledge.
Skills allow you to move part of that knowledge directly into the repository.
That means the knowledge travels alongside the code.
When someone clones a project, they also get the workflows.
When someone creates a fork, they also inherit the processes.
When someone onboards a new developer, skills are part of the onboarding.
The Analogy with GitHub Actions
When GitHub Actions appeared, many thought it was simply a more convenient way to run scripts.
Over time it became critical infrastructure.
Today no one questions the importance of:
.github/workflows/
Because that’s where much of the development cycle automation lives.
.claude/skills could follow a similar path.
Not as a replacement for GitHub Actions.
But as the layer where the team’s intelligent procedures live.
The Birth of the Programmable Repository
Historically a repository contained:
- Code.
- Configuration.
- Documentation.
Now it’s starting to contain something else.
Behavior.
Not software behavior.
Agent behavior.
We’re seeing the first steps toward repositories that don’t just store code, but also teach agents how to work within them.
That change is huge.
Because it transforms the repository from a passive structure into an active source of operational knowledge.
Why This Matters for Lean Teams
The teams that will benefit most probably won’t be large enterprises.
They’ll be teams that need to scale knowledge without scaling meetings.
Every time a skill captures an operational practice:
- It reduces onboarding time.
- It decreases repetitive errors.
- It standardizes processes.
- It increases consistency.
- It multiplies expertise.
A new developer can leverage procedures built by the team over months or years.
And the agent can apply them automatically.
The Most Important Signal
The real news isn’t that Claude Code is adding plugins.
The news is that Anthropic seems to be betting on an architecture where value doesn’t live solely in the model.
It lives in the specialization layer.
Models will keep improving.
But real differentiation could come from the skills each organization builds on top of them.
The same way we all use Git, but each company has different workflows.
Conclusion
For years we thought the future of agents depended mainly on increasingly intelligent models.
Claude Code is suggesting something different.
Maybe the next productivity leap won’t come from a better model.
Maybe it’ll come from repositories capable of teaching agents how to work.
If that vision materializes, .claude/skills could end up being one of the most important folders in any modern project.
Not because it contains code.
But because it will contain the team’s accumulated experience.