Oct 17, 2025 | 8 min read

---

Anthropic released a new feature yesterday called Skills. Skills are a simple way to build powerful automations without writing a single line of code. What makes Skills so interesting is that you don’t create software with programming and syntax, instead you describe your intent and a repeatable process you want to automate and Claude figures out how to make it happen.

Skills may sound similar to Claude’s Artifacts (and a few of Anthropic’s other offerings…), but they serve a different purpose. Artifacts help you build a tangible piece of software, but Skills help you do something. Skills turn a repetitive task into an on-demand utility that you can run anytime.

This provides two meaningful advantages:

• Accessibility: Skills aren’t just for programmers, anyone can create or use a Skill. While Skills can be run in Claude Code, they stand out from more technical alternatives by working equally well in Claude on your phone or your computer.
• Flexibility: Skills can include scripts, images, datasets, or any other supporting files you may need to solve a difficult problem.

This opens up a world of possibilities:

• A project manager can build a Skill that aggregates updates from every project tracker across the company — automatically generating a personalized status report for their next meeting.
• A marketer can create a Skill that applies brand guidelines to any public marketing document by injecting approved logos, fonts, and official assets.
• A designer can build a Skill to lint a design, checking that it meets both the current WCAG accessibility standards and the upcoming APCA contrast standards.
• A data analyst can build a Skill that cleans, normalizes, and reformats messy spreadsheets using real Python and Pandas code — transforming raw CSVs into polished summaries with a single prompt.
• A software developer can build anything from an API schema validator that checks JSON payloads against stored schemas, to a benchmark profiler that visualizes performance regressions over time.
• And a nerd like me can automate practically anything I want — without writing any code.

Your First Skill

The first Skill I created was a YouTube Audio Downloader. This came to mind immediately because it’s a task I automate often. I like to listen to talks from YouTube in my favorite podcast player, instead of having YouTube interrupt me with ads every ten minutes.

It was also a simple proof of concept that I could try before building something more powerful. It’s a problem I understand well, and this approach has the added benefit of working on my iPhone. The lack of a terminal on iOS means I can’t run tools like yt-dlp, but now I can use Claude to do it from anywhere.

A Naive Implementation

My first attempt was as straightforward as possible: I described exactly what I wanted in plain English.

---
name: youtube-audio-downloader
description: This skill downloads YouTube videos and transforms them into mp3s in one step.
---

# YouTube Audio Downloader

## Instructions

This package should use the yt-dlp Python package to download a YouTube video from a given URL, and then uses post-processing options to convert that video to an mp3. The end goal is for a user to have an mp3 file that they can drop into their favorite audio player.

## Examples

When the user asks for the audio from an mp3, you will invoke a command like this.

import yt_dlp
video_url = 'https://www.youtube.com/watch?v=example_video_id'

# Set options for downloading and converting to MP3
ydl_opts = {
'format': 'bestaudio/best',  # Download the best audio quality available
'extractaudio': True,         # Extract audio only
'audioformat': 'mp3',         # Convert to mp3
'outtmpl': '%(title)s.%(ext)s',  # Save the file with the video title
'postprocessors': [{           # Define post-processing options
'key': 'FFmpegExtractAudio',  # Use FFmpeg to extract audio
'preferredcodec': 'mp3',       # Set the preferred codec to mp3
'preferredquality': '192',      # Set the preferred quality (192 kbps)
}],
}

# Create a YDL object and download the video
with yt_dlp.YoutubeDL(ydl_opts) as ydl:
ydl.download([video_url])

This code is one example, you should explore the other formats and prompt the user for their preferences if their intent is not obvious.

My first try worked surprisingly well. I didn’t go in with much strategy beyond trying things and seeing what happened. That’s something I love about AI — there’s no penalty for an experiment gone wrong, so you can try infinite approaches and throw away whatever doesn’t work.

Creating a Skill only takes a few steps:

• Provide a name and description.
• Add instructions that describe the problem you’re solving.
• Share examples. I didn’t want to write much code, so I asked Claude to generate a short sample yt-dlp script someone might run.

This Skill worked well, but why stop at good when I knew it could be better?

A Better Approach

In Anthropic’s help docs for Skills, they mention the ability to add resources. A resource can be an image, a file, or a script.

Your Skill should live in a file called SKILL.md. If you create a resources directory, you can add any assets that your Skill might need to reference. And if you create a scripts folder, Claude gains the ability to invoke a Python or JavaScript interpreter with any package from NPM or PyPI. This is incredibly powerful! This means your skill can run and execute real code, transforming a simple text description into a full app.

Rather than writing this code myself, I pointed Claude at the documentation for Skills and at my SKILL.md, asking it to rewrite my Skill into a Skill with a script.

Based on this blog post (https://docs.claude.com/en/docs/agents-and-tools/agent-skills) and this skill Users/mergesort/.claude/skills/youtube-audio-downloader-skill SKILL.md, can you transform our plain-text instructions into a utility script?

Claude followed my request perfectly. It created a new download_audio.py in my scripts folder, and simplified my SKILL.md. Instead of embedding code directly in my SKILL.md, Claude referenced the new script and even added better usage examples than the ones I had provided.

---
name: youtube-audio-downloader
description: This skill downloads YouTube videos and transforms them into mp3s in one step.
---

# YouTube Audio Downloader

This skill downloads audio from YouTube videos (or other supported sites) and converts them to MP3 files.

## Instructions

Use the `scripts/download_audio.py` utility script to download and convert videos to MP3 format. The script uses yt-dlp to extract the best quality audio and convert it to MP3.

**Note:** yt-dlp supports many video platforms beyond YouTube, so this skill works with most video URLs the user provides.

## Usage

Execute the utility script with the video URL:

bash
python3 scripts/download_audio.py "VIDEO_URL"

### Options

- `-q, --quality KBPS`: Set audio quality in kbps (default: 192)
- `-o, --output TEMPLATE`: Set output filename template (default: `%(title)s.%(ext)s`)

### Examples

**Basic usage (192 kbps, video title as filename):**
bash
python3 scripts/download_audio.py "https://www.youtube.com/watch?v=dQw4w9WgXcQ"

**Custom quality (320 kbps):**
bash
python3 scripts/download_audio.py -q 320 "https://www.youtube.com/watch?v=dQw4w9WgXcQ"


**Custom output filename:**
bash
python3 scripts/download_audio.py -o "my_audio.%(ext)s" "https://www.youtube.com/watch?v=dQw4w9WgXcQ"

## Behavior

- The script downloads the best available audio quality from the source
- Converts audio to MP3 format using FFmpeg
- Saves the file in the current working directory with the video title as the filename (by default)
- Provides clear success/error messages
- Exits with error code 1 if download fails

If the user's preferences are unclear (quality, output location, filename format), ask before downloading.

Going above and beyond what it was asked to do, Claude even listed the benefits of this approach for me:

Following the documentation’s approach, this transformation provides:

• Token efficiency: Only the script’s output consumes tokens, not the code itself
• Consistency: The same deterministic script runs every time
• Maintainability: Script logic is in one place, not scattered across examples
• Reusability: The script can be tested and improved independently

All of these benefits are useful, but what I appreciated most was that I didn’t have to write any code to get here. Pointing an AI at well-written documentation and having it update my existing work is a powerful technique that I turn to often, and expect will become even more common as these systems improve.

Publishing Your Skill

If you want to use a Skill on your computer, you can drop it into the .claude folder in your home directory or into your project’s .claude directory. But the real magic is making a Skill available in the Claude app on your phone or computer.

To make a Skill available everywhere, follow these steps:

• Create a zip file that contains your SKILL.md, your resources folder, and your scripts folder.
• Open Claude and go to Settings -> Capabilities.
• Upload the zip file where it says Upload Skill.

Once you do that, your custom piece of software will be available anywhere and everywhere.

Skills vs. MCP

So what about MCPs?

MCPs are complex and mostly aimed at programmers. They connect an AI system to external APIs and resources in an agentic way — going beyond what REST can offer. Skills, on the other hand, are less of a contract and more of a task for the model to execute autonomously.

MCPs also tend to be token-inefficient, to the point where I often recommend avoiding them. That’s especially true when you’re working in an agentic coding environment like Claude Code, where it’s usually better to make Claude aware of an equivalent CLI tool in your CLAUDE.md so you don’t waste valuable space in your context window.

I don’t think MCPs are going away because they still play an important role — but they’re quickly falling out of favor because of their complexity, latency, and growing security concerns. Skills can’t fully replace an MCP (yet… I say because the AI space moves fast), but they’re already filling many of the same needs by formalizing a simpler way to run automated code within an agentic system.

Developing Your Skills

I’ve been saying for a while now that we’re at the beginning of an era of on-demand software.

Skills aren’t the first manifestation of that. There have been plenty of ideas like this before, even from Anthropic with MCPs, Artifacts, Subagents, and god knows what else. What’s novel about Skills is that they lower the barrier for people to create and run small pieces of software that do exactly what you need, when you need it.

We’re starting to see these ideas converge into more cohesive visions — ones that go beyond developers and software development. When anyone can create a Skill, anyone can improve one, share one, or build on top of one. Their simplicity makes them more accessible, and when technology becomes more accessible, we begin to see creativity flourish.

And so, there’s never been a better time to learn a new skill.