Skillsmaxxing: How to Manage and Distribute AI Agent Skills Across Your Team

I learned this from people who explain it better than I do. Go watch them first:

• Startup Ideas podcast (Greg Isenberg + Remy/AI with Remy) — the episode that started this: https://www.youtube.com/watch?v=xHsftiyT9pQ
• Firecrawl — "Best Claude Code Skills to Try in 2026" (19 skills ranked, Agent Skills standard breakdown): https://www.firecrawl.dev/blog/best-claude-code-skills
• Taskade — "Best Claude Code Skills in 2026" (12 skills, progressive disclosure): https://www.taskade.com/blog/claude-code-skills
• Nate Herk — "two kinds of skills" framework (Capability Uplift vs. Encoded Preference): https://www.youtube.com/watch?v=RAZVk5NPNtE
• Anthropic official skills repo — https://github.com/anthropics/skills (157K+ stars)

This page distills what I learned from those sources into one reference. I am not the expert. They are. I am putting it on one page so I can find it easily. If it helps you, go follow them and give them the traffic.

---

Brand new to skills? Start here

A skill is a folder with a SKILL.md file inside it. The file tells your AI coding agent how to do something specific. You set it up once. The agent uses it forever.

At startup, the agent reads only the name and description from each skill — about 100 tokens per skill. When you give it a task, it checks whether any skill matches. If one does, it loads the full instructions. If not, nothing loads. Your context stays clean. This is called progressive disclosure.

Skills are an open standard. The Agent Skills specification is adopted by Claude Code, Codex CLI, Cursor, Gemini CLI, and GitHub Copilot. A skill you write for Claude Code works in Codex and Cursor with minimal adaptation. (Source: Firecrawl's breakdown — https://www.firecrawl.dev/blog/best-claude-code-skills)

Where skills live

Two kinds of skills

Nate Herk defines two categories that change how you think about building them (source: https://www.youtube.com/watch?v=RAZVk5NPNtE):

• Capability Uplift — gives the agent abilities it does not have. Web scraping, PDF generation, browser testing. Without the skill, the agent cannot do the task.
• Encoded Preference — captures your team's specific way of doing something the agent already knows. NDA reviews, commit formats, code review checklists. The agent can do the task, but the skill encodes how you want it done.

Both load the same way. Knowing which kind you need changes how you build.

---

The people who understand how to use skills, plugins, and Claude Code have an unfair advantage. But sharing those skills across a team? Nobody has figured that out yet.

That is the problem Remy (aka AI with Remy) and Greg Isenberg tackle on the Startup Ideas podcast. Remy runs his entire company on a stack of Claude Code skills. He has prompts that turn skill folders into GitHub plugins that work in both Codex and Claude Code. And he has a clear answer for the team distribution problem.

This article synthesizes the episode and builds on it with practical guidance for managing skills across Hermes, Claude Code, Cursor, and Codex.

What is a skill, really?

A skill is a folder of instructions that tells an AI coding agent how to do something specific, repeatedly. You set it up once. You use it forever.

What makes a good skill

After working through hundreds of skills across the ecosystem, the ones that work share a pattern. (Source: Firecrawl — https://www.firecrawl.dev/blog/best-claude-code-skills)

Signs a skill will work:

• The description reads like a routing rule. "Use when the user asks to extract form fields from a PDF" beats "Helps with documents."
• Code does the deterministic work. The model should not sort lists, parse PDFs, or validate schemas. Those jobs belong in bundled scripts.
• Lean SKILL.md, fat references/. Core instructions fit on a phone screen. Push edge cases into companion files that load on demand.
• One skill, one job. Skills that try to do five things trigger at the wrong time.
• Examples over rules. Three worked examples beat twenty bullet-pointed constraints.

Signs a skill will cause problems:

• A 4,000-token SKILL.md that loads on every adjacent task and burns context.
• Vague triggers like "use this for productivity tasks." Productivity is not a category.
• Self-reported metadata: skills that claim capabilities their code cannot deliver.
• No examples. If you cannot infer the use case from the SKILL.md, neither can the agent.

Remy describes skills as the thing that gets you the best output out of Claude Code. He runs his company with a bunch of them. They handle repeatable processes: email formatting, newsletter research, copywriting guidance. They compose into chains where multiple skills work together to produce a result.

The concept exists across all the major AI coding tools:

• Claude Code loads skills from .claude/skills/ in a project. Each skill is a SKILL.md file with instructions the agent reads on demand.
• Cursor loads skills from .cursor/skills/. The agent picks them up when relevant.
• Codex has its own skill mechanism. The episode mentions a prompt that builds a GitHub plugin compatible with both Codex and Claude Code.
• Hermes Agent uses ~/.hermes/skills/ with a richer structure: each skill has a SKILL.md, optional references, scripts, and templates. Skills load into future sessions and persist across them.

Same idea across all of them. Different implementation.

Why skills matter more than prompts

A prompt is something you type once. A skill is something you set up once and use forever.

That distinction matters for teams. If you have a junior developer or someone in marketing who is not technically savvy, you cannot expect them to write good prompts. But you can give them a skill that encodes the right behavior and let them use it.

Remy makes this point directly: the minute you bring on someone who is not AI-native, things break. They do not understand folder structures. They do not know how to set up skills properly. File-sharing approaches fall apart.

The alternative, letting everyone figure it out themselves, produces ten slightly different versions of the same skill, none of them maintained.

The team distribution problem

You have built a skill that formats emails exactly how you want. You taught Claude the format once, saved it as a skill, and now every email your team sends follows the standard. You want everyone on the team to have that skill.

Three approaches people try, and why they fail:

Slack or email a skill file. Someone downloads it, uploads it to their setup. It works until you make a change. Then their file does not update. If they make a change, you do not get it. You end up with duplicates.

A shared drive folder. Same problem, worse. Everyone has to know the folder exists, know how to install from it, and remember to check for updates. Obsidian has the same problem. Now everyone needs Obsidian installed, which is a pain.

One giant skill file. Hugging everyone into a single file means the marketing person gets the finance skills they do not need and the finance person gets the copywriting guidance they will never use.

The real problem is update propagation. A skill is only valuable if it stays current. When you improve it, the whole team should get the improvement. When someone on the team improves it, you should get their improvement back.

The solution: GitHub repository as a skill marketplace

Remy's answer: put all your skills in a GitHub repository and make it a plugin.

It sounds obvious in hindsight. Most people do not do it.

The setup:

1. Create a GitHub repo for your skills. Organize them by department or function: copywriting, finance, newsletter, development, whatever makes sense for your team.
2. Each skill lives in its own folder following a consistent contract. The skill has a SKILL.md with the instructions, and any supporting files it needs.
3. Point your AI coding tool at the repo as a marketplace or plugin source. In Claude Code, this means adding the repo to your skills configuration. In Codex, the episode mentions a prompt that builds a plugin from your skill folder that works in both Codex and Claude Code.
4. When you update a skill in the repo, everyone gets the update the next time they pull. When someone on the team improves a skill, they open a pull request and everyone benefits.

The marketplace is like an app store. The plugins are the apps. You install only the ones your role needs.

Organizing skills by department

Remy breaks his skills down by department. Each department gets its own plugin. The copywriting person gets the copywriting plugin but not the finance plugin. The finance person gets the finance plugin but not the copywriting one.

This separation matters:

• People see only what they need. Less noise, faster adoption.
• Each department can improve its own skills without stepping on others.
• You do not have to give everyone access to everything. A junior marketer does not need your financial analysis skills.

The episode shows Remy walking through his newsletter skills as an example: weekly research, intake, drafting, editing. Each step is a skill. They compose into a chain that produces a finished newsletter.

Skill chains

A skill chain is when multiple skills work together to produce a result that no single skill could produce alone.

Remy uses this concept explicitly. You might have one skill for research, one for drafting, one for editing, and one for formatting. Run them in sequence and you get a finished piece. Run them in parallel and you get different angles on the same topic.

One skill saves you time on a task. A chain of skills automates a workflow. That is where the real time savings show up.

The episode mentions that Remy drops prompts that let you take your existing skill folders and have Claude build a GitHub plugin out of them. One that works in both Codex and Claude Code. That is the bridge between "I have some skills on my laptop" and "my whole team can use these."

How to manage skills across different tools

The episode focuses on Claude Code, but the skill concept applies across the ecosystem. Each tool handles skills differently.

Claude Code

Claude Code loads skills from .claude/skills/ in a project directory. Each skill is a SKILL.md file. Claude reads the skill when it determines the skill is relevant to the task.

Skills are project-scoped. Put them in .claude/skills/ inside the repo you are working on. Claude Code walks up .claude/skills/ only as far as the current repo's git root. A shared ~/Projects/.claude/skills/ would silently never load across repo boundaries.

For cross-repo skills, put them at ~/.claude/skills/<name>/SKILL.md. This is the user-level location, available in every project.

Skills can include references to vault notes and external resources. Keep the skill file lean and link out to detailed documentation.

Cursor

Cursor uses .cursor/skills/ for skill loading. The agent picks up skills on demand when they are relevant.

Cursor rules (.cursor/rules) are always-on instructions. Skills are on-demand. Know the difference: rules fire every time, skills fire when relevant.

Natural language works as an opener. You can tell Cursor what you want in plain language and it will load the relevant skills.

Cursor's AI agent skills ecosystem is growing. The Vercel agent-skills library is one example. You can install skills with npx skills add.

Codex

Codex has its own skill mechanism. The episode mentions that Remy has a prompt that takes your existing skill folders and builds a GitHub plugin that works in both Codex and Claude Code.

Skills can be portable across tools. If you structure them well, the same skill folder can be consumed by Claude Code, Codex, and potentially Cursor with minimal adaptation.

Do not lock your skills into one tool's proprietary format. Structure them as clear instructions with supporting files, and they can travel.

Hermes Agent

Hermes Agent uses ~/.hermes/skills/<name>/SKILL.md as its skill format. Each skill has a SKILL.md with instructions, optional references/ for detailed documentation, scripts/ for executable code, and templates/ for reusable templates.

Skills persist across sessions. Once installed, they load into future sessions automatically. Hermes has a skills hub for browsing installed skills.

Skills are the primary mechanism for teaching Hermes new capabilities. The agent improves through skills, not through one-off instructions. Profile support means you can have different skill sets for different contexts: work, personal, client projects.

Cross-tool skill design

If you want skills that work across Claude Code, Cursor, Codex, and Hermes, design them with these principles:

1. Keep the core instruction in a single SKILL.md. Do not split logic across multiple files unless the tool requires it.
2. Use clear, specific instructions. "When the user asks about X, do Y" beats vague guidance.
3. Separate instructions from data. If your skill needs reference material, link to it rather than embedding it. This keeps the skill file small and makes updates easier.
4. Test in one tool, then adapt. Start with Claude Code since it has the most mature skill system. Once the skill works there, adapt the folder structure for Cursor and Codex.
5. Use GitHub as the source of truth. One repo, one version of each skill. Pull updates across all your tools.

The practical playbook

If you want to start skillsmaxxing today, here is the sequence:

Step 1: Audit what you already have. Look at your prompt history. What tasks do you repeat? What instructions do you find yourself typing over and over? Those are skill candidates.

Step 2: Build one skill. Pick the highest-impact repeat task. Write a SKILL.md that encodes exactly what you want the agent to do. Test it. Refine it until it produces consistent results.

Step 3: Put it in GitHub. Create a repo. Add the skill folder. Make it public or private, whichever fits your team.

Step 4: Connect it to your tools. Point Claude Code at the repo. Do the same for Cursor and Codex if you use them.

Step 5: Add more skills by department. Build out the skill set for each function on your team. Copywriting, finance, research, development. Whatever maps to your organization.

Step 6: Create skill chains. Identify workflows that span multiple steps. Compose skills into chains. Test the chains end to end.

Step 7: Share with your team. Give everyone access to the repo. Show them how to install the skills they need. Make it easy to pull updates.

Step 8: Maintain. Skills rot if nobody owns them. Assign ownership. Review periodically. Prune what is not used.

Remy's excellent contribution

A few things from the episode are worth highlighting because they are easy to miss:

• Skills are not prompts. A prompt is ephemeral. A skill is persistent. The value compounds over time as you accumulate skills and chains.
• Distribution is the hard part. Building a skill is straightforward. Sharing it across a team without creating duplicates and version drift is where most people fail. The GitHub plugin approach solves this.
• Departmental separation is underrated. One giant skill file for everyone creates confusion. Organizing by function lets each person see only what matters to them.
• Skill chains are where the time savings show up. A single skill saves you minutes. A chain of skills that automates a workflow saves you hours and produces consistent output.
• Portability matters. If your skills are locked to one tool, you are at the mercy of that tool's future. Build them to travel.

Go learn from the experts

This page is a distillation. The real expertise lives with the people who built these tools and the people who teach them. Go follow them. They explain it better than I do.

The podcast that started it:

• Startup Ideas podcast (Greg Isenberg) — the episode that kicked off this whole rabbit hole: https://www.youtube.com/watch?v=xHsftiyT9pQ. Greg puts playbooks out there for everyone to use. Go learn from him.

The skill ecosystem breakdown:

• Firecrawl — "Best Claude Code Skills to Try in 2026" ranks 19 skills and explains the Agent Skills open standard: https://www.firecrawl.dev/blog/best-claude-code-skills
• Taskade — "Best Claude Code Skills in 2026" covers 12 skills with progressive disclosure: https://www.taskade.com/blog/claude-code-skills
• Nate Herk — the "two kinds of skills" framework (Capability Uplift vs. Encoded Preference): https://www.youtube.com/watch?v=RAZVk5NPNtE

The official source:

• Anthropic skills repo — the canonical skills repository with 157K+ GitHub stars: https://github.com/anthropics/skills

The Hermes educators:

• Jack Roberts — Skool communities (https://www.skool.com/ai-automation-vault and https://www.skool.com/aiautomationsbyjack/) plus YouTube tutorials
• Sharbel A. — "Learn 95% of Hermes Agent in 31 Minutes": https://www.youtube.com/watch?v=Ta2wg6xPaY4
• Wanderloots (Calum) — "Improved AI Memory — Full Hermes Tutorial": https://www.youtube.com/watch?v=R1TNGOZAOZs
• Tonbi Studio — Hermes Desktop plugins deep-dive: https://x.com/tonbistudio/status/2087215004600913988

The Claude Design educator:

• Jack Roberts — "Claude Design just got 10X Better" (gauntlet loop technique): https://www.youtube.com/watch?v=jq9LRwE0-GQ

The official Hermes docs:

• https://hermes-agent.nousresearch.com/docs/

---

You can do this. Go start. Build one skill. Put it in a repo. Share it with your team. Then build another. The compounding is real. The people above built the tools and the tutorials. Your job is to use them.

---

Source: Startup Ideas podcast, "Biggest Unlock for AI Agents in 2026: Skillsmaxxing" with Greg Isenberg and Remy (AI with Remy). Video: https://www.youtube.com/watch?v=xHsftiyT9pQ

This article synthesizes the podcast episode in original wording. No content is copied verbatim from the transcript. Attribution to the Startup Ideas podcast, Greg Isenberg, and Remy is included above.