Feature Deep Dive

Claude Cowork Skills:
How They Work and How to Build Your Own

Skills are markdown files that teach Claude new capabilities. No code, no infrastructure, no build steps. Write instructions in plain English, and Claude follows them every time.

What Are Claude Cowork Skills?

A skill is a SKILL.md file with YAML frontmatter and markdown instructions. You write what you want Claude to do, and Claude adds it to its toolkit. When a relevant task comes up, Claude reads the skill and follows the instructions automatically. You can also trigger skills directly by typing /skill-name in any Cowork session.

Skills follow the Agent Skills open standard from agentskills.io. This means your skills aren't locked into Claude. They work across multiple AI tools that support the same specification.

Everything is file-based. Markdown and JSON. No programming languages, no APIs to call, no servers to run. If you can write a checklist, you can write a skill. The hard part isn't the format. It's knowing which workflows to encode and how to write instructions that produce consistent results. That's where working with a specialist makes a difference.

Two Types of Skills

Skills fall into two categories based on how Claude uses them.

Reference Skills

Domain knowledge Claude applies to whatever it's currently working on. Conventions, patterns, style guides, terminology. These run inline alongside conversation context.

Examples:

  • • Brand voice and formatting guidelines
  • • Industry terminology definitions
  • • Code conventions and naming standards
  • • Regulatory compliance checklists

Typically set user-invocable: false so they stay hidden from the / menu. Claude draws on them automatically.

Task Skills

Step-by-step instructions for specific actions. Generating reports, reviewing documents, processing data. Usually triggered by typing /skill-name in your session.

Examples:

  • • Weekly market report generation
  • • Contract review and risk assessment
  • • Invoice processing and data extraction
  • • Competitive analysis briefings

Often set disable-model-invocation: true so they only run when you ask for them.

SKILL.md Anatomy: Every Field Explained

Every skill starts with a YAML frontmatter block (between --- markers) followed by markdown instructions. Here's a complete example:

---
name: weekly-report
description: Generates weekly performance reports. Use when asked for weekly summaries.
argument-hint: [date-range]
disable-model-invocation: false
user-invocable: true
allowed-tools: Read, Grep
context: fork
model: sonnet
---

When generating a weekly report:
1. Pull data from connected sources
2. Organize by department
3. Highlight anomalies
4. Format as PDF using company template

Frontmatter Fields

name
The skill's display name and /command trigger. Lowercase, hyphens allowed, 64 characters max. This is what appears in the autocomplete menu and what you type to invoke the skill. Example: weekly-report becomes /weekly-report.
description
What the skill does, in plain language. Claude reads this to decide when to auto-invoke the skill. Write it like you're telling a colleague when to use this tool. Be specific: "Generates weekly performance reports" is better than "Helps with reports."
argument-hint
Placeholder text shown in the autocomplete menu. Tells users what to type after the command. Example: [date-range] shows as /weekly-report [date-range] in the menu. Whatever the user types after the command gets captured as $ARGUMENTS.
disable-model-invocation
When true, the skill only runs if the user types /skill-name. Claude won't trigger it on its own. Set this for skills that make significant changes, send emails, or modify files. When false (the default), Claude can auto-invoke when it thinks the skill is relevant.
user-invocable
When false, the skill is hidden from the / menu entirely. It becomes background knowledge that Claude draws on silently. Good for reference skills like style guides, conventions, or domain terminology.
allowed-tools
Which tools Claude can use without asking permission while the skill is active. Normally Claude asks before reading or writing files. Setting allowed-tools: Read, Grep lets the skill search and read files without pausing for approval.
context
Controls where the skill runs. inline runs it in the main conversation, which is great for quick reference lookups. fork runs it in an isolated subagent with its own context window. Use fork for long tasks that produce large outputs, so they don't clutter your main thread.
model
Override which Claude model runs this skill. Use a faster model like Haiku for simple lookups or quick formatting tasks. Use Sonnet or Opus for complex analysis. This keeps costs down without sacrificing quality where it matters.

File Structure

A skill can be a single SKILL.md file. Or it can be a folder with supporting files that Claude references when running the skill:

my-skill/
├── SKILL.md           # Main instructions (required)
├── template.md        # Template for Claude to fill in
├── examples/
│   └── sample.md      # Example output showing expected format
└── scripts/
    └── validate.sh    # Script Claude can execute

Only SKILL.md is required. The supporting files are optional but powerful. Templates enforce consistent output formatting. Examples show Claude what "good" looks like. Scripts let Claude validate its own work.

Where Skills Live: The Scope Hierarchy

Skills can exist in four locations. Higher-priority locations win when skill names conflict.

1

Enterprise Managed Settings

Highest priority. Set by organization admins. Apply to all users in the org. Read-only for individual team members. This is how companies enforce standard workflows across their team.

2

Personal: ~/.claude/skills/

Your personal skills, available across all projects. Put your daily workflow skills here: your writing style guide, your preferred report format, your weekly review process.

3

Project: .claude/skills/

Shared with your team via git. Project-specific skills that everyone on the project uses. Good for team conventions, project templates, and shared workflows.

4

Plugin: <plugin>/skills/

Skills bundled inside plugins. Available wherever that plugin is enabled. Namespaced as plugin:skill-name to avoid conflicts. The 11 official Anthropic plugins each ship with their own skills.

Bundled Skills That Ship with Claude

Five skills come pre-installed with Claude Code and Cowork. You don't need to create or configure them.

/batch <instruction>

Runs large-scale changes in parallel. Claude spawns one sub-agent per unit of work. If you need to process 50 files the same way, /batch handles them concurrently instead of one at a time.

/claude-api

Loads the Claude API reference for your programming language. Useful when you're building integrations or custom tools that call the Claude API.

/debug [description]

Troubleshoots session issues by reading debug logs. When something isn't working right, /debug digs into the logs and tells you what went wrong.

/loop [interval] <prompt>

Runs a prompt repeatedly on a schedule. Pair this with /schedule for recurring tasks like daily file organization, weekly report generation, or hourly data checks.

/simplify [focus]

Reviews recent changes for quality. Spawns three parallel review agents that check your work from different angles. Think of it as an automated peer review.

Custom Skill Examples

The real power of claude cowork skills is building your own. Here are three examples from different industries.

Weekly Market Report for Real Estate Agents

A real estate agent runs this every Monday morning. It pulls new listings, calculates price changes by neighborhood, checks mortgage rate trends, and outputs a client-ready newsletter. What used to take 2 hours now takes 3 minutes.

---
name: weekly-market-report
description: Generates a weekly market analysis report for client distribution
disable-model-invocation: true
---

Generate a weekly market report:
1. Pull new listings from MLS connector (last 7 days)
2. Calculate median price changes by neighborhood
3. Identify notable sales (above/below ask)
4. Check mortgage rate trends
5. Format using the template in ./templates/market-report.md
6. Save to ~/Reports/weekly/ with date in filename
7. Draft email summary for client newsletter

Contract Review for Law Firms

Zack Shapiro's "Claude-Native Law Firm" approach: encode your analytical frameworks, preferred formats, and professional judgment into skills. Claude opens .docx files at the XML level and writes tracked changes attributed to the reviewing lawyer's name.

---
name: contract-review
description: Reviews contracts for standard issues and red flags
---

When reviewing a contract:
1. Identify contract type (NDA, MSA, employment, lease, etc.)
2. Check for missing standard clauses per ./reference/required-clauses.md
3. Flag unusual liability provisions
4. Note indemnification scope
5. Check termination conditions
6. Compare fee structure against market rates in ./reference/market-rates.md
7. Generate a summary memo with: risk level (low/medium/high),
   key terms, recommended changes

Self-Improving Meta-Skill

This pattern, open-sourced at github.com/rebelytics/one-skill-to-rule-them-all, watches other skills perform and logs corrections you make. Over time, it updates skill files with those learnings. Your skills get better the more you use them. A marketing team used this approach to build banner upload, dev ticket generation, and image alt text skills that improved with each batch.

The meta-skill observes each session, records when you correct Claude's output, identifies patterns in those corrections, and applies them to the source skill files. It's how you go from "good enough" to "exactly right" without rewriting skills from scratch.

Dynamic Features

Skills aren't static checklists. Four features make them responsive to context.

$ARGUMENTS

Captures whatever the user types after the command. When you type /weekly-report Q1 2026, the skill receives $ARGUMENTS = "Q1 2026". Your instructions can reference this variable to customize the output based on user input.

Supporting Files

Reference templates, examples, and scripts from within your SKILL.md. Claude reads them when needed. A market report skill can reference ./templates/market-report.md for formatting, and Claude fills in the template with fresh data each time.

Progressive Disclosure

Start with a brief SKILL.md and reference detailed docs in separate files. Claude loads them only when needed. This keeps token usage efficient. A complex compliance skill might have 10 pages of reference material, but Claude only reads the relevant section for each task.

Subagent Execution

Set context: fork to run a skill in an isolated subagent with its own context window. Long tasks won't clutter your main conversation. The subagent completes the work and returns results. Good for report generation, batch processing, and multi-step analysis.

How We Build Skills for Your Business

NYC Claw identifies your repetitive workflows and turns them into custom skills. One-time setup, ongoing value. No consulting retainer required.

1

Identify your workflows

We map what you do weekly and monthly. Which tasks take hours? Which follow the same pattern every time? Which require copying data between tools? Those are your skill candidates.

2

Write the SKILL.md files

Each workflow becomes a skill with step-by-step instructions, supporting templates, and example outputs. We configure the frontmatter so skills trigger at the right time with the right permissions.

3

Connect your tools

Skills work best with connectors wired up. We configure your CRM, project tracker, email, and document storage via MCP so skills can pull and push data automatically.

4

Test, tune, and train

We iterate on prompts until output quality matches your expectations. Then we train your team on using the skills, customizing them, and building new ones. See the setup guide for more on the process.

Want to understand pricing before the call? Check the Cowork pricing guide for plan details and what's included at each tier.

Your workflows, encoded in skills

Every business has 5-10 tasks that follow the same pattern every week. Let's turn yours into skills that run in minutes instead of hours.

Book a Free 15-Minute Call

15 minutes · No commitment · We'll map your top skill candidates

Frequently Asked Questions

Do I need to know how to code to create Claude Cowork skills?
No. Skills are written entirely in markdown with YAML frontmatter. There's no programming language, no build step, and no infrastructure to manage. If you can write a checklist in a text file, you can write a skill. That said, getting the instructions right so Claude produces consistent, high-quality output takes iteration and domain knowledge.
What's the difference between a skill and a plugin?
A plugin is a package that bundles skills, commands, connectors, sub-agents, and hooks together. A skill is one component inside a plugin (or standalone in your .claude/skills/ directory). Think of plugins as the container and skills as one type of content inside it.
Can skills connect to external tools like my CRM or email?
Skills themselves are instruction files. They tell Claude what to do. The actual connections to external tools come from connectors configured in the plugin's .mcp.json file. When a skill runs, it can use any connector that's been set up: HubSpot, Slack, Google Drive, Salesforce, and 30+ others.
How many skills can I have active at once?
There's no hard limit. Skills load into Claude's context only when relevant, so having 20 skills installed won't slow anything down. The scope hierarchy (enterprise, personal, project, plugin) determines which skills are available in which context and which take priority when names conflict.
Can Claude improve its own skills over time?
Yes. One well-known pattern is the self-improving meta-skill, where Claude watches its own sessions, logs corrections you make, and updates the skill file with those learnings. The open-source "one-skill-to-rule-them-all" project on GitHub demonstrates this approach. NYC Claw can set this up so your skills get better the more you use them.