Prelude
The first time many teams use Claude for real work, not just experimenting, they ask it to draft a customer email. The result is technically correct. It hits the right points, answers the question, and uses proper grammar. It also sounds nothing like the team or anyone at the company.
It is generic in the way that all AI output is generic when the model has no context about who you are or how you communicate. Claude cowork skills solve this problem by giving Claude persistent, specific knowledge about your business.
Most people rewrite that email by hand. Then they do the same thing the next day. And the day after that. They use Claude as a starting point, but the gap between what it produces and what they actually need is wide enough that the time savings are marginal.
That experience is what leads to skills. Not the concept in the abstract, but the practical need to close the gap between what Claude knows by default and what it needs to know to be genuinely useful for a specific business.
Skills are instructions you write in plain language that teach Claude how to handle your work. Your brand voice, your code review standards, your email conventions, your documentation style. Once you create them, Claude applies them automatically. The generic output problem disappears.
This guide covers how skills work inside Claude's collaborative workspace called Cowork, how the Anthropic Marketplace distributes them through plugins, and how systemprompt.io fits into the picture as the platform where you create and manage those skills. It walks through the practical details of building skills, bundling them into plugins, sharing them across a team, and measuring their impact. Much of what follows comes from building skills across real projects and observing how teams adopt them.
The Problem
Claude is extraordinarily capable out of the box. It can write code, draft prose, analyse data, generate reports, and handle dozens of other tasks with impressive quality. But "impressive quality" and "right for your business" are not the same thing.
Every organisation has institutional knowledge that lives in people's heads. The way you address customers in support emails. The specific patterns your engineering team prefers in pull request descriptions. The tone your marketing team uses on social media versus in whitepapers.
The compliance language your legal team requires in outbound communications. None of this is written down in a form that Claude can access, and even when it is written down, pasting a style guide into every conversation does not scale.
The result is a productivity gap. Claude can do the work, but not the way your team does the work. People end up spending time editing AI output to match internal standards, which defeats much of the purpose of using AI assistance in the first place.
This problem compounds across a team. If five people are each prompting Claude slightly differently to achieve the same brand voice, you get five slightly different interpretations. There is no consistency, no shared standard, and no way to improve the instructions over time in a way that benefits everyone.
This pattern appears repeatedly across organisations. Individual contributors figure out prompts that work well for them, keep those prompts in personal note files, and never share them. The organisation's collective knowledge about how to use Claude effectively remains fragmented across dozens of personal workflows. When someone leaves the team, their prompt expertise leaves with them.
What was missing was a layer between the model and the user. Something that could carry persistent, shared instructions that Claude would apply automatically without anyone needing to copy and paste prompt fragments. That layer is what skills provide.
The Journey
What Cowork Actually Is
Cowork is Claude's collaborative workspace, available on Pro and Team plans at claude.ai. If you have used Claude through the web interface, you have used the conversational mode. Cowork extends that with persistent context, shared projects, and the ability to install plugins that modify Claude's behaviour.
The key difference for this discussion is that Cowork supports plugins. A plugin is an integration that runs alongside Claude, giving it access to external tools and knowledge. When you install a plugin from the Anthropic Marketplace, it becomes available in your Cowork sessions. Claude can call the plugin's tools, read its data, and follow its instructions.
This is where skills enter the picture. A plugin can carry skills, which are sets of instructions that tell Claude how to approach specific tasks. When you install a plugin that includes skills, Claude gains that knowledge automatically.
You do not need to explain your brand voice at the start of every conversation. You do not need to paste your code review checklist. The plugin delivers that context.
For teams on the Team plan, plugins installed by an administrator apply to everyone on the team. This is how you get consistency. One person writes the skill, publishes it through a plugin, and every team member gets the same instructions delivered to Claude automatically.
Understanding Skills
A skill is, at its core, a document written in plain language that tells Claude how to behave in a particular context. There is no special syntax, no programming language, no schema to learn. You write instructions the way you would explain something to a capable new colleague.
Here is what a simple brand voice skill looks like.
Brand Voice for Customer Communications
When writing customer-facing content for our company, follow these guidelines.
We write in British English. Use "realise" not "realize", "optimise" not "optimize", "organisation" not "organization".
Our tone is professional but warm. We avoid jargon unless the audience is technical. We never use superlatives like "best-in-class" or "world-leading". We prefer concrete statements over vague claims.
When addressing customers directly, use "you" and "your". When referring to our company, use "we" and "our". Never refer to the company in the third person in customer communications.
Short paragraphs. Maximum four sentences per paragraph. Use bullet points for lists of three or more items.
Always end customer emails with a clear next step. Tell them what will happen next or what they should do next.
That is it. There is no compilation step, no deployment pipeline, no API to integrate. You write the instructions, save them as a skill, and Claude starts following them.
The specificity is what makes skills valuable. Generic instructions produce generic output. Specific instructions, the kind that reference your actual conventions and preferences, produce output that sounds like it came from your team.
As a practical example, consider a code review checklist for a Rust codebase. The instructions describe conventions around error handling, a preference for explicit types over inference in public APIs, and a rule that every public function needs a doc comment.
Before the skill, someone would paste these expectations into every code review conversation. After the skill, Claude applies them automatically. The time saved is not in the review itself but in the setup. Every conversation starts with Claude already knowing what the team expects.
The Anthropic Marketplace
The Anthropic Marketplace is where you find and install plugins for Claude. Think of it as a plugin marketplace for AI capabilities. Publishers create plugins that extend what Claude can do, and users install them into their Cowork workspace.
Plugins on the marketplace range from simple skill bundles to full integrations that connect Claude to external services. Some plugins give Claude access to specific APIs. Others provide specialised knowledge for particular industries or workflows. The systemprompt.io plugin falls into both categories. It connects Claude to your skill library on systemprompt.io and provides the MCP server infrastructure that makes those skills available in real time.
Installing a plugin takes about thirty seconds. You open the Marketplace in Cowork, search for the plugin you want, click Install, and authorise the connection. The getting started guide walks through this process in detail if you have not done it before.
What matters for this discussion is that the Marketplace is the distribution mechanism. You create skills on systemprompt.io, bundle them into a plugin, publish to the Marketplace, and anyone who installs that plugin gets your skills. For internal teams, you can publish private plugins that only your organisation can see. For consultants and agencies, you can publish public plugins that any Claude user can install.
systemprompt.io as Your Skill Platform
systemprompt.io is where you create, manage, and publish skills. It provides the authoring environment, the API that serves skills to Claude, and the analytics that tell you how your skills are being used.
The platform works like this. You log in to the admin dashboard at systemprompt.io/admin. From there you can create skills, organise them into collections, assign them to plugins, and monitor usage. The dashboard gives you a central place to manage everything your team has built.
Many users initially treat the platform like a document editor. Write the skill, save it, move on. Over time it becomes clear that the real value is in iteration. You publish a skill, watch how it performs through the analytics, identify where Claude is not following the instructions closely enough, refine the wording, and publish an update. The skills that work best are the ones that have been through several rounds of this cycle.
The platform also handles versioning. When you update a skill, the previous version is preserved. If a new version causes problems, you can roll back. This matters more than you might think.
In one real-world case, a brand voice skill was updated to be more concise, and a paragraph about how to handle complaints was accidentally removed. The customer support team noticed immediately because Claude's responses changed. Being able to revert to the previous version while the new one was fixed saved a lot of disruption.
Creating Your First Skill
Go to systemprompt.io/admin and log in. If you do not have an account yet, the free tier gives you enough to get started.
Click My Skills in the sidebar, then click Create Skill. You will see a form with a name field and an instructions editor. The name should be descriptive enough that you can find it later. "Brand Voice" is better than "Skill 1".
The instructions editor is where the real work happens. Write your instructions in plain language, as if you were explaining the task to someone who is competent but unfamiliar with your specific conventions. Be explicit about what you want. Be equally explicit about what you do not want. Ambiguity in skill instructions produces inconsistent results.
Here is an example of an email drafting skill that works well in practice.
Internal Email Drafting
When drafting internal emails for our team, follow these conventions.
Subject lines should be specific and actionable. "Q1 Marketing Budget Review" is good. "Update" is not.
Open with the purpose of the email in the first sentence. Do not start with pleasantries. "I'm writing to get your approval on the revised timeline" is direct and clear.
Use bullet points for any list of action items, decisions, or options. Number them if order matters.
Close with a specific ask and a deadline. "Could you review and respond by Friday at 3pm?" gives people a clear expectation.
Keep the tone collegial but efficient. We are a small team and we value each other's time.
Never use "please find attached" or "as per our previous discussion". These phrases add nothing.
Save the skill and it becomes available immediately through the systemprompt.io plugin. If you already have the plugin installed in Cowork, Claude can use this skill in your next conversation.
The recommended pattern is to start with one skill that addresses your most frequent frustration with Claude's default output. For most people, that is either brand voice or a specific document format. Get one skill working well before you create more. The temptation is to build a library of twenty skills in an afternoon, but skills that are written quickly tend to be vague, and vague skills do not change Claude's behaviour enough to be worth having.
Common Issues
Plugin not appearing in Cowork after installation. Close your Cowork session and open a new one. Plugins load when a session starts, so an existing session will not pick up a newly installed plugin until it is refreshed.
Skill instructions not taking effect. Verify the skill is assigned to the correct plugin and that the plugin is installed in your workspace. On the systemprompt.io dashboard, check that the skill status is "active". If the skill is active but Claude is not following the instructions, the wording may be too vague. Rewrite the instructions to be more specific and direct.
MCP server connection dropping mid-session. This usually indicates a timeout or authentication expiry. Reinstall the plugin from the Marketplace to refresh the connection. If the problem persists, check the Claude Code MCP servers guide for debugging steps.
Skill changes not reflected for team members. After updating a skill on systemprompt.io, team members need to start a new Cowork session to pick up the latest version. Existing sessions continue using the version that was loaded when the session began.
How Plugins Bundle Skills and MCP Servers
A plugin is a package that combines skills with MCP (Model Context Protocol) servers. Skills provide the instructions. MCP servers provide the tools and data access. Together, they give Claude both the knowledge of what to do and the ability to do it.
For example, a project management plugin might include a skill that tells Claude how your team writes user stories, plus an MCP server that connects to your issue tracker. Claude knows the format you expect (from the skill) and can create issues directly in your tracker (through the MCP server). If you want to understand MCP servers in more depth, the guide on Claude Code MCP servers covers the technical details.
When you create a plugin on systemprompt.io, you select which skills to include and configure which MCP servers to attach. The plugin becomes a single installable unit that users can add to their Cowork workspace. This bundling is important because it means you can create a coherent experience. A "Content Marketing" plugin might include skills for blog writing, social media posts, and newsletter drafting, plus an MCP server that accesses your content calendar. Everything the team needs for content work, packaged together.
The MCP server side of plugins is optional. A plugin that only contains skills is perfectly valid and often the right starting point. You can always add MCP server functionality later as your needs evolve.
Sharing Skills Across a Team
This is where skills move from a personal productivity tool to an organisational capability. On the Team plan, an administrator can install plugins that apply to every team member. When they do, every person on the team gets the same skills delivered to Claude automatically.
The impact of this is more significant than it might seem on the surface. Before shared skills, each person on the team would prompt Claude differently.
One person might include detailed brand guidelines in their system prompt. Another might paste a few bullet points. A third might not include any guidance at all. The output varied accordingly.
With shared skills, the team aligns without anyone needing to remember to include the right context. The new developer who joined last week gets the same code review standards as the senior engineer who wrote them. The marketing intern gets the same brand voice guidelines as the head of communications. The consistency is automatic.
When shared skills are rolled out to a team, adoption typically happens in two phases. First, people notice that Claude's output is better without them doing anything differently. The brand voice skill is already active, so emails and documents come out closer to the team's standard.
Second, people start asking for more skills. The engineering team wants a skill for commit messages. The design team wants a skill for writing design briefs. The sales team wants a skill for proposal formatting.
That second phase is where skills become self-sustaining. Once people see the benefit, they start contributing their own expertise. The best skills often come from the person on the team who is most particular about how something should be done. Their high standards, which previously made them the bottleneck for reviews and approvals, get encoded into a skill that lifts everyone's output.
To share skills, you create them on systemprompt.io, add them to a plugin, and have your team administrator install the plugin in your Cowork workspace. The process is straightforward, but the organisational change it enables is not trivial. You are, in effect, codifying institutional knowledge and making it available to an AI that assists every member of your team.
Practical Examples
Here are three skills used regularly across teams, with enough detail that you could create similar ones for your own work.
Brand Voice Skill
This skill handles all external communications. It typically takes about three weeks to develop well, starting with a rough draft and refining it each time Claude produces something that does not match the target voice.
The skill covers tone (professional, direct, never condescending), vocabulary (British English, no jargon in customer communications, technical terms are fine in documentation), structure (short paragraphs, clear headings, bullet points for lists), and prohibitions (no superlatives, no buzzwords, no passive voice unless the active voice would sound accusatory).
The most valuable part of this skill turns out to be the prohibitions. Telling Claude what not to do is often more effective than telling it what to do. "Never use the word 'innovative' in customer communications" is precise. "Write in an innovative way" is meaningless. In practice, the prohibitions section of a brand voice skill often ends up longer than the rest of the skill combined.
Code Review Skill
This skill is for our Rust codebase and it covers the things we check in every pull request. Error handling patterns (prefer thiserror for library code, anyhow for application code), naming conventions (snake_case for functions, PascalCase for types, SCREAMING_CASE for constants), documentation requirements (every public item needs a doc comment, examples are required for complex APIs), and common mistakes to flag (unwrap in production code, missing error context in chains, overly broad trait bounds).
The team adopted it because it solved a real problem. Code reviews were taking too long because reviewers kept leaving the same comments about style and convention. The skill handles the routine checks, which frees reviewers to focus on logic, architecture, and correctness.
Structuring this skill with sections for each category of feedback helps Claude organise its review comments in a way that is easy to scan. Random observations in no particular order are harder to act on than categorised feedback.
Email Drafting Skill
This is the simplest of the three but it saves the most time across the team. It covers our conventions for internal emails (direct, no pleasantries, action items in bullet points, deadline in the closing), customer emails (warm, specific, always include a next step), and partner emails (formal, thorough, reference relevant agreements or previous conversations).
The skill distinguishes between these three audiences because they require genuinely different approaches. Before the skill, people would ask Claude to "write an email" and get a generic result. With the skill, Claude asks which audience the email is for and applies the right conventions automatically.
Marketplace Analytics
Once your skills are in use, you want to know whether they are working. systemprompt.io provides analytics that show you how your skills are being used, how often they are applied, and how they perform over time.
The dashboard shows basic metrics like invocation count, which tells you how often each skill is being used. More interesting is the breakdown by user and by context. You can see which team members are using which skills most frequently, which helps you identify gaps. If the engineering team is using the code review skill heavily but the documentation skill rarely, that tells you something. Maybe the documentation skill needs improvement, or maybe the team is not writing much documentation.
Usage tracking also helps with the iteration cycle I mentioned earlier. When you update a skill, you can watch the analytics to see whether the update changes usage patterns. A skill that is used less after an update might have become less relevant or less effective. A skill that is used more might have addressed a gap that was limiting its usefulness before.
The analytics are not just about vanity metrics. They feed directly into skill improvement. Reviewing analytics monthly and using them to prioritise which skills need attention is a recommended practice. The highest-usage skills should get the most refinement time because improvements there have the broadest impact.
The Build vs Buy Decision
The Marketplace gives you two paths. You can create your own skills from scratch, or you can install plugins that other publishers have built. Most teams end up doing both.
Building your own skills makes sense when the knowledge is specific to your organisation. No one else can write your brand voice skill because no one else knows your brand voice. No one else can write your code review skill because no one else knows your codebase conventions. Custom skills encode proprietary knowledge, and that is their primary value.
Installing marketplace plugins makes sense for generic capabilities. A plugin that helps Claude write better SQL queries, for example, encodes general expertise that applies across many teams. A plugin that improves Claude's ability to analyse financial data might be useful regardless of your specific industry. These are capabilities where the publisher's expertise benefits from broad use and community feedback.
A straightforward decision framework works well here. If the skill requires knowledge that only your team has, build it yourself. If the skill encodes general expertise that many teams need, check the Marketplace first. If nothing on the Marketplace fits, consider whether the skill you build could be useful to others and whether publishing it would make sense.
There is also a middle path. Install a marketplace plugin for general capability and layer your own skills on top for customisation. A general writing plugin might improve Claude's prose quality across the board.
Your brand voice skill then narrows that improved writing to match your specific standards. The general plugin raises the floor. Your custom skill shapes the output.
Iteration and Maintenance
Skills are not a write-once-forget artefact. The best skills evolve over time as you learn what works and what does not. Treat skills the way you treat code. They should be reviewed, refined, and occasionally rewritten entirely.
The most common reason to update a skill is that you notice Claude not following the instructions in a particular edge case. Your brand voice skill might handle blog posts well but produce the wrong tone for error messages. Rather than writing a separate skill for error messages, you add a section to the existing skill that covers that context. Over time, the skill becomes more comprehensive and more effective.
Another common reason to update is organisational change. Your company rebrands, your coding standards evolve, your customer communication policy shifts. Skills need to reflect the current state of your conventions, not the state they were in when you first wrote the skill.
Assigning ownership to skills works well, the same way you assign ownership to documentation. Someone should be responsible for each skill, reviewing it periodically and updating it when needed. Without ownership, skills decay. The conventions they encode drift from reality, and people stop trusting them.
The Lesson
The deeper lesson from working with skills is about the nature of expertise in the age of AI assistance. Every organisation has implicit knowledge that is difficult to transfer. Training new employees takes months because so much of what they need to know is not written down anywhere.
Skills change that equation. When you write a skill, you are making implicit knowledge explicit. You are documenting your conventions, your preferences, and your standards in a form that is not only readable by humans but also actionable by an AI.
This has a compounding effect. The more skills you create, the more of your organisational knowledge is captured and shareable. New team members benefit immediately because Claude already knows the conventions. Experienced team members benefit because they spend less time reviewing and correcting output that does not match expectations.
The Anthropic Marketplace amplifies this further by creating a distribution mechanism. Skills that are useful to one team might be useful to many teams. The Marketplace lets publishers share their expertise broadly, and it lets users benefit from expertise they would not have time to develop themselves.
But the real value is not in any individual skill or plugin. It is in the practice of systematically capturing what your team knows and making it available through AI assistance. That practice, creating skills, testing them, refining them, sharing them, is what turns Claude from a general-purpose assistant into a team member who understands how your organisation works.
Conclusion
Skills are the bridge between what Claude can do and what your business needs Claude to do. They are simple to create, powerful when shared, and they improve with use. The combination of Cowork as the workspace, the Anthropic Marketplace as the distribution channel, and systemprompt.io as the creation platform gives you a complete system for building AI assistance that reflects your organisation's expertise.
Start with one skill. Pick the task where Claude's generic output frustrates you most and write specific instructions for how you want it done. Install it through the systemprompt.io plugin and test it in Cowork. Refine the wording until Claude's output matches your expectations. Then share it with your team.
Once you see the difference that one well-crafted skill makes, you will understand why this matters. Not because the technology is impressive, though it is. Because the gap between generic AI output and output that genuinely fits your business is the gap between a tool you tolerate and a tool you rely on. Skills close that gap.
If you are new to the Marketplace, start with the getting started guide. If you want to understand the MCP server infrastructure that powers plugins, read the Claude Code MCP servers guide. And when you are ready to create your first skill, systemprompt.io/admin is where you begin.