Advanced Skills with skill-creator

In Module 2, you hand-crafted a simple single-file skill from scratch. That’s the best way to understand what skills are and how they work — but it’s not the only way to create them, and most real-world skills need more than just a SKILL.md file.

In this module, you’ll use skill-creator to generate a more sophisticated skill, then enhance it with templates and supporting files.

The skill-creator Skill

skill-creator is what we call a meta-skill: a skill whose purpose is to create other skills. This demonstrates that skills can be sophisticated tools, not just behavioral tweaks. It’s also your first encounter with a skill from Anthropic’s official marketplace.

If you followed Module 1, you already installed the example-skills plugin which includes skill-creator. If not, install it now:

claude plugin install example-skills@anthropic-agent-skills

If it’s already installed, you can check for updates:

claude plugin update example-skills@anthropic-agent-skills

The marketplace concept will be explained fully in Module 4. For now, know that you’ve installed a pre-built plugin maintained by Anthropic that bundles several skills together.

Read the skill-creator’s own SKILL.md to see how a well-crafted skill is structured:

less ~/.claude/plugins/cache/anthropic-agent-skills/example-skills/*/skills/skill-creator/SKILL.md

Notice how the skill describes its own purpose, provides clear examples, and sets constraints. This is the template that skill-creator itself will follow when generating new skills.

Generating abstract-writer

Now use skill-creator to generate a new skill called abstract-writer. This skill will help you write compelling conference talk abstracts tailored to specific conferences.

Invoke skill-creator — type /skill and press Tab to autocomplete, then paste the description below:

> /example-skills:skill-creator

Then provide the following description of the skill you want to create:

Create a skill called "abstract-writer" that generates conference talk abstracts
tailored to specific conferences. It should accept a talk topic and target conference,
produce a compelling abstract with title, summary, learning objectives, and target
audience. Keep abstracts under 300 words.

skill-creator will walk you through a structured workflow with Research, Testing, and Submit phases. When it asks how you want to evaluate the skill, choose Quick vibe check for now — we’ll draft it and iterate based on your feedback.

Notice the Full eval loop option? skill-creator can run test cases with and without your skill, then show side-by-side comparisons using a built-in eval viewer. This is powerful for iterating on production skills — you write test prompts, define assertions, and measure whether your changes actually improve output. We’ll revisit skill evaluation as a topic in Module 4.

skill-creator will generate a new SKILL.md file at ~/.claude/skills/abstract-writer/SKILL.md.

Inspect what was generated:

less ~/.claude/skills/abstract-writer/SKILL.md

Compare this to your manual work in Module 2 with talk-outliner. What did skill-creator do well? What would you change?

Common observations:

  • The description might be too broad or too narrow for reliable triggering

  • Body instructions might be generic rather than domain-specific

  • The overall structure follows skill conventions correctly

  • But there’s no supporting content — no examples, no templates

skill-creator gives you a solid starting point, but generated skills always need refinement. And for more complex skills, you’ll want to add supporting files.

Refining and Extending

Let’s improve the generated abstract-writer skill by adding templates and refining its instructions. This is where we go beyond Module 2’s single-file approach.

Tighten the Description

The description controls when Claude invokes the skill. A vague description leads to missed triggers or false positives.

Edit ~/.claude/skills/abstract-writer/SKILL.md and update the description to be more specific. Before (what skill-creator likely generated):

A skill that helps write conference talk abstracts

After:

Generate conference talk abstracts tailored to specific conferences. Use when the user
wants to write, draft, or improve a conference talk abstract, CFP submission, or
speaking proposal.

The refined version is specific about use cases (write, draft, improve), contexts (CFP, speaking proposal), and trigger conditions.

Improve the Body

The body tells Claude how to behave when the skill is invoked. Generic instructions lead to generic results.

Add these constraints to the body section of SKILL.md:

When generating abstracts:

- Ask for the talk topic and target conference if not provided
- Check for conference-specific templates in the templates/ directory
- Tailor the abstract to the conference's audience and technical level
- Include a compelling title (under 15 words)
- Provide a clear summary of what attendees will learn
- List 3-5 concrete learning objectives
- Identify the target audience and any prerequisites
- Keep the total abstract under 300 words unless a template specifies otherwise
- Use active voice and avoid marketing jargon

Add Templates

This is the key new concept in Module 3. Skills can include supporting files that Claude reads and uses when executing the skill.

Create a templates directory:

mkdir -p ~/.claude/skills/abstract-writer/templates

Create ~/.claude/skills/abstract-writer/templates/lightning-talk.md using your favorite editor with the content from Code Preview, or switch to the Run tab to create the file in one step:

  • Code Preview

  • Run

# Lightning Talk Abstract Template

**Format:** 5-minute presentation
**Word limit:** 100 words maximum

## Structure

**Title:** Punchy, specific, under 10 words

**Abstract:** Single compelling paragraph that:
- States the core problem or opportunity
- Hints at the solution or insight
- Promises one concrete takeaway

**Key Takeaways:** (bullet list)
- Takeaway 1
- Takeaway 2
- Takeaway 3

**Target Audience:** Who will benefit most from this talk

---

Example:

**Title:** Debugging Kubernetes with eBPF in Under 5 Minutes

**Abstract:** When your pods crash and logs don't help, eBPF can trace system calls in real-time without modifying your application. I'll demonstrate a live debugging workflow using bpftrace to diagnose a memory leak in a production cluster, walking through the exact commands and showing the output that led to the fix. You'll leave with a copy-paste-ready debugging script.

**Key Takeaways:**
- How to attach eBPF probes to running containers
- Reading bpftrace output to identify resource leaks
- Three debugging patterns for common pod failures

**Target Audience:** Platform engineers and SREs familiar with Kubernetes basics
cat > ~/.claude/skills/abstract-writer/templates/lightning-talk.md << 'TEMPLATE_EOF'
# Lightning Talk Abstract Template

**Format:** 5-minute presentation
**Word limit:** 100 words maximum

## Structure

**Title:** Punchy, specific, under 10 words

**Abstract:** Single compelling paragraph that:
- States the core problem or opportunity
- Hints at the solution or insight
- Promises one concrete takeaway

**Key Takeaways:** (bullet list)
- Takeaway 1
- Takeaway 2
- Takeaway 3

**Target Audience:** Who will benefit most from this talk

---

Example:

**Title:** Debugging Kubernetes with eBPF in Under 5 Minutes

**Abstract:** When your pods crash and logs don't help, eBPF can trace system calls in real-time without modifying your application. I'll demonstrate a live debugging workflow using bpftrace to diagnose a memory leak in a production cluster, walking through the exact commands and showing the output that led to the fix. You'll leave with a copy-paste-ready debugging script.

**Key Takeaways:**
- How to attach eBPF probes to running containers
- Reading bpftrace output to identify resource leaks
- Three debugging patterns for common pod failures

**Target Audience:** Platform engineers and SREs familiar with Kubernetes basics
TEMPLATE_EOF

Now create ~/.claude/skills/abstract-writer/templates/full-session.md the same way — Code Preview to read, Run to create:

  • Code Preview

  • Run

# Full Session Abstract Template

**Format:** 30-45 minute presentation
**Word limit:** 250-300 words

## Structure

**Title:** Clear, specific, benefit-focused (under 15 words)

**Abstract:** 2-3 paragraphs covering:

Paragraph 1: The problem, challenge, or opportunity. Set the stage with context that resonates with the target audience.

Paragraph 2: Your approach, solution, or insights. What makes your perspective unique or valuable? Include real-world examples, data points, or lessons learned.

Paragraph 3: What attendees will take away. Concrete skills, patterns, tools, or strategies they can apply immediately.

**Learning Objectives:** (5 specific outcomes)
- Attendees will be able to [action verb] [specific skill/knowledge]
- Attendees will understand [concept] and how to apply it to [scenario]
- Attendees will learn [technique] for [solving X problem]
- Attendees will gain [capability] using [tool/method]
- Attendees will be able to [evaluate/implement/design] [outcome]

**Target Audience:** Be specific about role, experience level, and prerequisites

**Prerequisites:** What attendees should know or have done before attending

---

Example:

**Title:** From Monolith to Microservices: A Migration Pattern Language

**Abstract:**

Migrating from a monolith to microservices sounds simple in theory but is fraught with production incidents, team friction, and false starts in practice. Over two years, we broke apart a 500K-line Rails monolith serving 10M users into 30 microservices — and learned that the hard problems aren't technical, they're organizational.

This talk presents a pattern language for incremental migration: strangler fig for carving out services, event interception for decoupling databases, contract testing for preventing regressions, and team topologies for reducing coordination overhead. Each pattern is grounded in a real production story — the database deadlock that taught us about distributed transactions, the silent data corruption that forced us to build lineage tracking, the deploy that took down checkout because we didn't own our dependencies.

You'll walk away with a decision framework for sequencing migrations, a testing strategy that balances speed and safety, and tactics for keeping the monolith deployable while extraction is underway. If you're in the middle of a similar migration or planning one, this talk will save you from repeating our mistakes.

**Learning Objectives:**
- Attendees will be able to apply the strangler fig pattern to extract services incrementally without a full rewrite
- Attendees will understand how to decouple shared databases using event interception and saga patterns
- Attendees will learn contract testing strategies to prevent integration regressions across service boundaries
- Attendees will gain techniques for measuring migration progress using domain-driven design bounded contexts
- Attendees will be able to design team structures that minimize cross-service coordination using Team Topologies principles

**Target Audience:** Engineering leads, architects, and senior engineers at organizations running large monolithic applications who are evaluating or planning a microservices migration

**Prerequisites:** Familiarity with service-oriented architecture concepts and experience deploying production systems
cat > ~/.claude/skills/abstract-writer/templates/full-session.md << 'TEMPLATE_EOF'
# Full Session Abstract Template

**Format:** 30-45 minute presentation
**Word limit:** 250-300 words

## Structure

**Title:** Clear, specific, benefit-focused (under 15 words)

**Abstract:** 2-3 paragraphs covering:

Paragraph 1: The problem, challenge, or opportunity. Set the stage with context that resonates with the target audience.

Paragraph 2: Your approach, solution, or insights. What makes your perspective unique or valuable? Include real-world examples, data points, or lessons learned.

Paragraph 3: What attendees will take away. Concrete skills, patterns, tools, or strategies they can apply immediately.

**Learning Objectives:** (5 specific outcomes)
- Attendees will be able to [action verb] [specific skill/knowledge]
- Attendees will understand [concept] and how to apply it to [scenario]
- Attendees will learn [technique] for [solving X problem]
- Attendees will gain [capability] using [tool/method]
- Attendees will be able to [evaluate/implement/design] [outcome]

**Target Audience:** Be specific about role, experience level, and prerequisites

**Prerequisites:** What attendees should know or have done before attending

---

Example:

**Title:** From Monolith to Microservices: A Migration Pattern Language

**Abstract:**

Migrating from a monolith to microservices sounds simple in theory but is fraught with production incidents, team friction, and false starts in practice. Over two years, we broke apart a 500K-line Rails monolith serving 10M users into 30 microservices — and learned that the hard problems aren't technical, they're organizational.

This talk presents a pattern language for incremental migration: strangler fig for carving out services, event interception for decoupling databases, contract testing for preventing regressions, and team topologies for reducing coordination overhead. Each pattern is grounded in a real production story — the database deadlock that taught us about distributed transactions, the silent data corruption that forced us to build lineage tracking, the deploy that took down checkout because we didn't own our dependencies.

You'll walk away with a decision framework for sequencing migrations, a testing strategy that balances speed and safety, and tactics for keeping the monolith deployable while extraction is underway. If you're in the middle of a similar migration or planning one, this talk will save you from repeating our mistakes.

**Learning Objectives:**
- Attendees will be able to apply the strangler fig pattern to extract services incrementally without a full rewrite
- Attendees will understand how to decouple shared databases using event interception and saga patterns
- Attendees will learn contract testing strategies to prevent integration regressions across service boundaries
- Attendees will gain techniques for measuring migration progress using domain-driven design bounded contexts
- Attendees will be able to design team structures that minimize cross-service coordination using Team Topologies principles

**Target Audience:** Engineering leads, architects, and senior engineers at organizations running large monolithic applications who are evaluating or planning a microservices migration

**Prerequisites:** Familiarity with service-oriented architecture concepts and experience deploying production systems
TEMPLATE_EOF

Update SKILL.md to Reference Templates

Edit ~/.claude/skills/abstract-writer/SKILL.md and add this instruction to the body:

Before generating an abstract, check the templates/ directory for format-specific templates:
- lightning-talk.md for 5-minute presentations
- full-session.md for 30-45 minute presentations

If a matching template exists, follow its structure and constraints exactly.
If no template matches or the user specifies a different format, use general best practices.

Test the Refined Skill

Test the skill with a prompt for a lightning talk:

> I want to submit a lightning talk abstract to KubeCon about using eBPF for
  performance tracing. The talk would show a live demo of tracing network latency
  in a service mesh.

Claude should: * Recognize this as an abstract-writer task * Check the templates directory * Use the lightning-talk.md template * Generate a 100-word abstract with the structure from the template

Test again with a full session:

> Write a 40-minute conference talk abstract about adopting OpenTelemetry in a
  large organization. Target audience is platform engineers. The talk should cover
  our migration strategy, instrumentation patterns we developed, and lessons learned
  from rolling it out across 50 microservices.

Claude should use the full-session.md template and generate a 250-300 word abstract with learning objectives.

Compare these results to what talk-outliner from Module 2 would have produced. The templates give much more structure and consistency.

Skill Complexity Spectrum

Skills exist on a complexity spectrum. Understanding where a skill falls helps you choose the right approach.

Level Description Example

Instruction-only

Pure SKILL.md — behavioral instructions, no supporting files

talk-outliner (Module 2) — tells Claude how to structure an outline

With supporting files

SKILL.md + templates, reference data, or configuration

abstract-writer (this module) — includes format templates for different talk types

With executable components

SKILL.md + Python/bash scripts that Claude can run

trip-report (Module 4) — includes a formatting script

The talk-outliner you built in Module 2 was instruction-only: just a SKILL.md file with behavioral guidance.

The abstract-writer you’ve created here is more sophisticated: it has a SKILL.md plus supporting template files that Claude reads and follows.

In Module 4, you’ll build trip-report, a skill with executable components that can run scripts and produce formatted output. You’ll also learn how to bundle these three conference-related skills (talk-outliner, abstract-writer, and trip-report) into a distributable marketplace that others can install.

Summary

You’ve now created a skill using skill-creator and enhanced it with templates and supporting files. Key takeaways:

  • skill-creator accelerates skill creation but generated skills need refinement

  • Descriptions control when a skill triggers — make them specific

  • Body instructions and examples shape output quality

  • Skills can include supporting files (templates, reference data) that Claude reads when executing

  • The progression is: instruction-only (Module 2) → with templates (Module 3) → with executables (Module 4)

Next up: Module 4, where you’ll build trip-report with executable components, then bundle all three conference skills into a distributable marketplace that others can install.