CHAPTERS
Why Claude Skills matter: reusable, on-demand AI workflows
Claire introduces Claude Skills as Anthropic’s new way to package repeatable AI workflows that can be invoked across Claude Code, the API, and claude.ai. She frames the episode as a practical guide: what Skills are, how to create them, and where they fit into day-to-day product/engineering work.
- •Claude Skills are a newly released Anthropic feature for reusable workflows
- •Works across Claude Code, claude.ai/web/desktop, and API (API not covered in depth)
- •Goal: show creation process plus concrete workflow ideas
Sponsor: ChatPRD (AI copilot for product docs and coordination)
A short sponsor segment explaining what ChatPRD does and who it’s for. Claire highlights integrations and the product’s positioning as a practical AI copilot for PM work.
- •Helps write product docs, automate coordination, and offer “AI CPO” coaching
- •Used by startups and large enterprises
- •Integrations: v0.dev, Google Drive, Slack, Linear, Confluence, more
- •Free trial link mentioned: chatprd.ai/howiai
What Claude Skills are (and how they differ from Projects/custom GPTs)
Claude Skills are described as task-specific instruction sets and context that can be called on demand. Claire contrasts them with Projects/custom GPTs, which tend to be static context tied to a workspace/chat rather than dynamically invoked, task-specific workflows.
- •Skills = task-specific instructions/context callable on demand
- •Projects/custom GPTs = persistent context; less dynamic and less task-specific
- •Skills can include examples and even scripts to standardize execution
- •Preference for natural-language workflow definitions vs rigid if/then builders
Core benefits: discovery, context bundling, and consistent execution
Claire shares why Skills are useful in practice: they capture repeat tasks you’d otherwise copy/paste from prompt libraries. Skills can also bundle templates/examples via relative file references, and optionally include executable scripts for repeatable validation/processing.
- •Turns repeated prompt workflows into reusable “micro-instructions”
- •Relative file references let a Skill pull in templates/examples only when needed
- •Improves context management by scoping what’s loaded
- •Executable Python scripts reduce variability vs model-generated code
What a Claude Skill actually is: a folder you zip or point Claude Code at
She demystifies the “asset” behind a Skill: it’s simply a folder containing a SKILL.md (instructions) plus optional adjacent files. You either keep it locally for Claude Code to use, or zip the folder and upload it to claude.ai.
- •A Skill is a folder, not a special proprietary object
- •Contains SKILL.md plus optional resources/scripts/templates
- •Local usage: Claude Code reads Skills from your directory
- •Web usage: zip the folder and upload to claude.ai
Inside SKILL.md: metadata, instructions, and resource linking
Claire walks through the expected structure of a Skill file. The SKILL.md includes YAML-style metadata (name/description), detailed markdown instructions, and optional links to supporting files using relative paths.
- •Top section: metadata (name, description) to help Claude choose the Skill
- •Body: markdown instructions (prompt engineering lives here)
- •Resources referenced via relative paths (e.g., ./templates/file.md)
- •Supporting files can be templates, examples, or scripts
Demo attempt: using Claude web to generate a Skill (helpful, but messy)
She tries Claude’s built-in “create skills” capability by prompting claude.ai to generate a PRD Skill. While the generated Skill is instructive (very detailed, includes decision trees and questions), the flow creates too many files and download friction makes it impractical.
- •Claude-generated Skill shows what “good” looks like: detailed guidance, decision logic, formats
- •Includes clarifying questions for users and explicit output formatting
- •Adds extras (license, reference guides, many examples) beyond what’s needed
- •Download/export failed; would require manual file-by-file assembly
Better workflow: create Skills in Cursor using the docs as source-of-truth
Claire shows a faster approach: use Cursor with Anthropic’s documentation link and generate a “Skill to create Skills.” Cursor produces a clean folder with SKILL.md, templates/examples, and even a validation script—quickly and with files already local.
- •Start with an empty local “Claude Skills” folder opened in Cursor
- •Prompt Cursor to create a Skill-builder Skill using the official docs
- •Generates structured output: SKILL.md + templates/examples + validation script
- •Faster than web flow and avoids export/download issues
Adding reliability: Python validation scripts for Skill structure and quality
Cursor’s generated Skill includes a Python validator that checks YAML/formatting, file existence, and basic content constraints. Claire notes this can be overkill, but it demonstrates how executable scripts can enforce consistency and reduce errors.
- •Python script validates metadata/YAML formatting and expected files
- •Adds automated checks during Skill development
- •Helps standardize quality and catch broken references early
- •Illustrates “scripts bundled with Skills” concept
Testing in practice: invoking Skills with Claude Code (local repository)
With Skills stored locally, Claire runs Claude Code in the directory and asks it to use the Skill-creator Skill to generate a new workflow. Claude Code discovers available Skills, creates the new Skill folder, runs validation, and summarizes what it built.
- •Claude Code can discover and use Skills from the current directory
- •Prompt: use the Skill-creator Skill to generate a new workflow Skill
- •Creates directories/files in correct format and runs validation automatically
- •Outputs a summary of what was generated
Example Skill: changelog entries → user-facing newsletter
Claire demonstrates a concrete workflow: turning technical changelog entries into a subscriber-friendly newsletter. She highlights how Skills can be single-file and still powerful, and how Claude can infer Skill use based on context (e.g., the word “changelog”).
- •Generated Skill can be simple: metadata + long instruction set in one file
- •Claude inferred desired transformation when given “Here’s the latest changelog”
- •Output example: structured product updates newsletter (noted as emoji-heavy)
- •Skills are iteratively refined to match tone/format requirements
Example Skill: demo notes → personalized follow-up email
She repeats the pattern to quickly create another Skill that converts demo notes into tailored follow-up emails for trial prospects. The creation again takes only a few minutes and runs through the same validation and file-generation loop.
- •Use Skill-creator Skill to generate a new “demo-to-follow-up” workflow
- •Produces a ready-to-invoke Skill with instructions and validation
- •Demonstrates how quickly a Skill library can grow
- •Emphasizes iterative improvement over time
Uploading Skills to claude.ai: zip upload + naming constraints
Claire shows how to bring a local Skill into the Claude web UI by zipping the Skill folder and uploading it. She hits a constraint: skill names must be lowercase/hyphenated, fixes it, and confirms the Skill appears as an available capability in chat.
- •Web/Desktop usage requires zipping the Skill folder and uploading
- •Skill name constraint: lowercase letters (and typically hyphenated)
- •After upload, Skill becomes selectable/usable in claude.ai chat
- •Claude reads the Skill and can prompt for needed inputs (e.g., demo notes)
Wrap-up: recommended setup and next steps
Claire summarizes her recommended flow: maintain a local Skills repository, create a meta Skill that generates other Skills, and invoke them via Claude Code or upload zips to the web app. She closes with a call to subscribe/comment and teasers for future mini deep dives.
- •Best practice: keep a dedicated local Skills repo (optionally in GitHub)
- •Create a “Skill to create Skills” to standardize and speed up new workflows
- •Use via Claude Code locally; upload zips for web/desktop usage
- •Future episodes will cover more AI capabilities and practical workflows
