Claude Skills Explained: My Workflow for Creating Reusable AI Agents with Cursor and Claude Code

In this special mini-episode, we’re looking at a new feature from Anthropic: Claude Skills. If you’ve ever found yourself copying and pasting the same complex prompts into a chatbot over and over, you know how frustrating it is to reinvent the wheel. Claude Skills are meant to solve that exact problem by giving you a way to create reusable, on-demand instructions for Claude.

Unlike Claude Projects or custom GPTs, which keep a constant context within a specific chat, Skills are tools you can call on whenever you need them. Think of them as specialized micro-instructions that you can use in any conversation. They give you a structured way to handle the prompts and workflows you're probably already storing in Google Docs or Markdown files, but they also let you manage context, reference local files, and even run Python scripts.

What I love most is that you define Claude Skills using natural language. We have these amazing language models, so we should be able to instruct them in a way that feels normal. A Skill is really just a folder with a special SKILL.md file containing your instructions, plus any other templates or examples you want to bring in. You can then zip this folder and upload it to Claude.ai or, as I'll show you, use it directly with Claude Code.

I’m going to walk you through two different ways to create these skills. First, we'll try out Claude's own built-in skill creator, which is a good way to learn but has some rough edges. Then, I’ll show you my favorite way to do it, which is much faster, using the AI-native editor Cursor and the command-line interface for Claude Code.

Workflow 1: Learning the Ropes with Claude's Built-in Skill Creator

Anthropic included a skill that helps you create other skills right inside Claude, which is a clever touch. I decided to start here to see how Claude itself thinks a good skill should be put together. The process taught me a lot, but it wasn’t the most practical way to build a usable skill quickly.

Step 1: Kicking off the Process

To begin, I opened a new chat on claude.ai and just asked it for help. It knew what I was asking for right away.

Help me create skills.

Claude confirmed it understood and has a specialized 'meta-skill' for this task. True to my work at ChatPRD, I asked it to create a skill for generating a Product Requirements Document (PRD).

Step 2: Observing the Generation

Watching the process was fascinating. It followed a very structured workflow:

1. Read an example skill: It seemed to consult an internal template.
2. Examine detailed examples: It pulled in more context to understand the requirements.
3. Generate the `SKILL.md` file: It began writing the core instruction file.

I learned a lot from this process. The generated skill was incredibly detailed, much more so than I would have written on my own. It included sections for:

• When to use the skill: Clear triggers for the agent.
• Decision tree: Logic for handling different types of requests.
• Templates: A full PRD template to follow.
• Best practices: General advice for writing good PRDs.
• Clarifying questions: A list of questions for the agent to ask the user for more detail—a really smart addition I wouldn't have thought of!
• Keywords: A list of terms to help invoke the skill.

Step 3: The Results and Challenges

This is where things went a bit sideways. Claude created a total of 12 files, including a license file and a quick reference guide, when I really only needed about five. It was a lot of unnecessary overhead. The biggest issue, though, was that when I tried to download the zipped folder containing all the files, the download failed with an error.

Takeaway: While I wouldn't recommend this as your main method for creating skills, it's worth doing at least once. It gives you a great, detailed template for what a high-quality, robust skill looks like. For day-to-day efficiency, though, we need a better way.

Workflow 2: The Power Method: Building Skills with Cursor and Claude Code

This is my go-to workflow. It's faster, more reliable, and gives you a lot more control. By using the AI-powered editor Cursor with the command-line interface of Claude Code, you can create, test, and use skills pretty seamlessly.

Step 1: Setting Up Your Workspace

It all starts with a simple folder. I created a new, empty folder on my machine called claude-skills. This will serve as our repository. Then, I opened this folder directly in Cursor.

Step 2: Creating a "Meta-Skill" to Generate Other Skills

Instead of relying on Claude's built-in creator, I decided to build my own. I started a chat with Cursor's AI and gave it the official Anthropic Skills Documentation as context.

Create me a agent/skill for creating Claude skills. Here are the docs: https://docs.anthropic.com/claude/docs/skills-overview

This was way faster than the web app—it took about three minutes. Cursor created a new folder called create_skill containing a well-structured SKILL.md file and a few template files. The instructions were concise and followed the proper format with YAML metadata at the top.

What really surprised me was that Cursor also generated a Python validation script (validate_skill.py). This script checks the skill's YAML formatting, file references, and content structure. It was a perfect example of how you can bundle executable code within your skills for more technical, repeatable tasks.

Step 3: Generating a Specific Skill with Claude Code

Now that I had my own skill-builder, I could use it to generate other skills. I opened my terminal, moved into my claude-skills directory, and started Claude Code. Because Claude Code was running in that directory, it automatically had access to any skills I'd already created there.

I prompted it to create a skill for a task I do every week: turning our technical changelog entries into a user-facing newsletter.

Use the create_skill Skill to create a skill for turning change log entries into a user facing newsletter.

Claude Code immediately identified and used my create_skill skill. It read the instructions, created a new directory for the changelog-to-newsletter skill, wrote the SKILL.md file, and even ran the Python validation script on it. The whole process felt very smooth.

Step 4: Invoking the New Skill

With the new skill generated, it was time to test it out. This is where Claude Skills really start to feel useful. You don't need a special keyword or command. I just pasted my latest changelog directly into Claude Code.

Okay, here's the latest change log...

Because the changelog-to-newsletter skill was available in the directory, Claude figured out what I wanted to do. It recognized the content as a changelog and automatically applied the correct skill to turn it into an engaging, user-friendly newsletter. The output was a bit emoji-heavy for my taste, but that’s an easy fix—I can just go back and adjust the prompt in the SKILL.md file to get the tone and format right.

Workflow 3: Uploading and Using Skills in the Claude Web App

While the Claude Code workflow is great for development, a lot of us spend our day in the Claude.ai web or desktop app. The good news is, you can easily bring your locally created skills into that environment.

Step 1: Prepare and Zip Your Skill Folder

A Claude Skill is just a folder. To upload it, you first need to compress it into a .zip file. I navigated to my demo-to-follow-up skill folder (which I created using the same meta-skill process) in my file browser and created a zip archive.

Step 2: Upload to the Web UI

Inside the Claude web app, you can add new capabilities by uploading a skill. I tried uploading my zip file and hit a small snag: skill names must be all lowercase and can only contain letters, numbers, and hyphens. After quickly renaming my SKILL.md metadata name field to demo-to-follow-up, I re-zipped the folder and tried again.

Success! The skill was uploaded and immediately available for use in my chat. Claude even smoothly transitioned me into a conversation where it confirmed the skill was loaded and ready to go.

Now, I can just drop in notes from a customer demo, and Claude will use my custom instructions to draft a perfect, personalized follow-up email. This entire cycle—from idea to a usable skill in the web UI—took just a few minutes.

Conclusion: Your Turn to Build

Claude Skills are a really useful addition to the AI toolkit. They offer a structured, reusable way to automate the tasks you do most often. When you start building small, modular skills instead of just writing one-off prompts, you can make the work you get from AI more consistent and higher quality.

My recommended workflow is to use an AI-native editor like Cursor to create a 'meta-skill' for generating other skills, and then use Claude Code in a dedicated skills folder to quickly build and test new ones. Once they're working well, you can zip them up and add them to the web UI for daily use. I encourage you to think about your own repetitive tasks—what could you turn into a Claude Skill today?

Thanks for reading. If you liked this format, let us know! We’ll be doing more of these to share practical AI workflows that can help you at work and in your daily life.

Brought to you by

ChatPRD—An AI copilot for PMs and their teams

Episode Links

• Watch on YouTube
• Listen on Spotify
• Listen on Apple Podcasts