Skills in Claude Code and Cowork: How to Create Specialized Agents that Accelerate Your Work

If you use Claude Code for programming or Claude Cowork for knowledge tasks, you've probably already noticed that the AI responds well to general questions. But when you need it to follow a specific workflow from your team, apply your project's conventions, or execute a repetitive task exactly the way you want, things change. This is where Skills come in.

What are Skills?

Skills are modular packages of instructions that transform Claude from a generic agent into a specialist in a specific task. They function like an onboarding guide: they tell Claude what to do, how to do it, and when to activate.

In practice, a Skill is a folder containing a SKILL.md file that holds two parts:

• YAML Frontmatter: metadata that tells Claude when and how to use the Skill.
• Markdown Content: the detailed instructions that Claude follows when the Skill is activated.

It's a simple concept with enormous impact. Instead of repeating the same instructions in every conversation, you package them once, and Claude applies them automatically when it detects they are relevant.

Where Skills Work

Claude Code (Terminal)

Claude Code is the terminal agent for developers. Skills here focus on development tasks: generating tests, reviewing code, creating components, managing deployments, or following project conventions. When you run Claude Code in your repository, it scans the available Skills and activates them according to the context.

Claude Cowork (Desktop)

Cowork brings the same agentic capabilities to the desktop for knowledge work beyond code. Here, Skills are integrated into plugins that group abilities, connectors, slash commands, and sub-agents into a single package. You can use them to draft documents, organize files, synthesize research, process data in spreadsheets, or coordinate workflows between applications like Gmail, Google Drive, and Microsoft 365.

In both environments, the mechanism is the same: Claude detects the task, searches for relevant Skills, and applies them.

Anatomy of a Skill

Let's look at the basic structure of an SKILL.md file:

---
name: component-generator
description: This skill should be used when the user asks to "create a component",
  "generate a React component", "scaffold a new UI element", or mentions creating
  frontend components following the project conventions.
version: 1.0.0
---

After the frontmatter comes the body with the instructions:

# Component Generator

Generate React components following the project architecture.

## Steps

1. Create the component file in `src/components/`
2. Use TypeScript with proper typing
3. Follow the naming convention: PascalCase for components
4. Include a barrel export in the directory index
5. Add basic unit test in `__tests__/`

## Conventions

- Use functional components with hooks
- Styles via Tailwind CSS utility classes
- Props interface exported separately

Frontmatter Fields

Field	Function
name	The name of the Skill; it also becomes the /name command.
description	Key for automatic activation. Use concrete phrases a user would say.
version	The version of the Skill.
disable-model-invocation	If true, only the user can activate it manually.
user-invocable	If false, only Claude can activate it (background knowledge).
mode	If true, the Skill modifies Claude's general behavior.

The description field is the most important. Claude uses it to decide if a Skill is relevant to the current task. The more specific the activation phrases, the better the automatic detection will work.

How to Create a Skill Step-by-Step

The Quick Way: /skill-creator

Before explaining the manual process, there is a shortcut. Claude Code includes a Skill called /skill-creator that generates Skills for you. You just have to run /skill-creator and describe what you need: what task it should cover, what conventions to follow, and when it should activate. Claude automatically generates the folder structure, the SKILL.md with the correct frontmatter, and the detailed instructions.

It is the fastest way to start. If you have never created a Skill, use /skill-creator for your first one, and then adjust it manually if necessary.

The Manual Way

If you prefer total control or need to understand the structure to modify existing Skills:

1. Identify the Repetitive Task

Think about the instructions you constantly repeat to Claude. Creating components always with the same structure? Reviewing PRs following a checklist? Generating documentation in a specific format? That is a candidate for a Skill.

2. Create the File Structure

my-skill/
  SKILL.md          # Mandatory: instructions and metadata
  references/       # Optional: reference documentation
  examples/         # Optional: examples Claude can consult
  scripts/          # Optional: executable scripts

3. Write the SKILL.md

Start with the frontmatter. For the description, use the third-person formula with concrete activation phrases:

---
name: api-endpoint
description: This skill should be used when the user asks to "create an API endpoint",
  "add a new route", "scaffold a REST endpoint", or mentions building backend routes
  following the project patterns.
version: 0.1.0
---

Then, write the instructions in Markdown. Be clear, use numbered steps, and specify the conventions Claude must follow.

4. Register the Skill

In Claude Code, place the Skill folder in the location indicated by your plugin or project configuration. Claude will detect it automatically upon login.

For Cowork, Skills are packaged within plugins that you can install from the marketplace or register manually.

5. Test and Iterate

Invoke the Skill with /skill-name or simply describe the task and observe if Claude detects it automatically. Adjust the description and instructions based on the results.

Progressive Disclosure: The Key to Performance

Skills use a progressive disclosure system to avoid overloading Claude's context:

1. Metadata (~100 tokens): Loaded always. Only the name and description, enough for Claude to know if the Skill is relevant.
2. Full Instructions (less than 5,000 tokens): Loaded only when Claude decides the Skill applies.
3. Additional Resources (references, scripts, examples): Loaded on demand, only if Claude needs them.

This means you can have dozens of registered Skills without penalizing performance. Claude only consumes context from what it actually uses.

Where to Download Pre-Built Skills

You don't have to start from scratch. There are several repositories and platforms where you can download ready-to-use Skills:

• anthropics/skills — Anthropic's official repository with over 50 Skills organized into categories: document processing (Word, PDF, PowerPoint), development tools (Playwright, AWS, Git), data analysis, marketing, communication, and more. Apache 2.0 License.

• awesome-claude-skills — A community-curated list of Skills, resources, and tools to customize workflows with Claude Code.

• Claude Skills Marketplace — Marketplace integrated into Claude where you can explore and install Skills directly from the interface.

• LobeHub Skills Marketplace — A community platform with a wide catalog of categorized and ready-to-install Skills.

• Everything Claude Code — An exhaustive collection of configurations for Claude Code created by an Anthropic hackathon winner: agents, skills, hooks, commands, and rules.

• Claude Code Tresor — Professional-grade utilities including autonomous skills, expert agents, slash commands, and specialized prompts.

You can register these repositories as a plugin marketplace in Claude Code and install Skills directly from there.

Subagents: Skills with Superpowers

When a Skill needs more autonomy, you can convert it into a subagent. Subagents are specialized agents that run in their own context window with:

• A custom system prompt.
• Access to specific tools.
• Independent permissions.

Claude automatically delegates to the subagent when it detects a task that matches its description. The subagent works independently and returns the results.

This is especially powerful in Cowork, where you can have subagents for conversation analysis, document review, workflow coordination between applications, and more.

Best Practices for Effective Skills

Concrete descriptions, not vague ones. Instead of "helps with testing", use "This skill should be used when the user asks to 'write unit tests', 'add test coverage', 'create integration tests' for React components using Vitest."

Imperative and clear instructions. Write as if you are training a new team member. Use numbered steps, explicit conventions, and examples when necessary.

One Skill, one responsibility. It is better to have several focused Skills than one giant Skill that tries to cover everything.

Leverage additional resources. If your Skill needs reference to documentation, schemas, or complex examples, put them in the references/ and examples/ folders. They will only load when needed.

Iterate with real use. The first version will not be perfect. Observe how Claude interprets the instructions, adjust the activation phrases, and refine the steps.

Why It Matters for Your Business

Skills are not just a technical feature. They represent a shift in how organizations can package and reuse expert knowledge:

• A development team can standardize code patterns without relying on documentation that nobody reads.
• A marketing team can automate content generation while always following the brand guide.
• A support team can create response flows that consult internal data and follow specific protocols.

With Skills, your team's specialized knowledge becomes a tool that any member can invoke with a single command.

How We Can Help

At Navel Digital, we design and implement Skills and subagents adapted to each company's workflow. Whether it's accelerating software development with Claude Code or automating knowledge tasks with Cowork, we configure everything so your team works with an assistant that truly understands your processes.

If you want to explore how Skills can streamline your team's work, contact us at no obligation.