The Full Monty

This is where everything comes together.

You’ve built individual skills, composed them into a marketplace, and worked with pre-built tools. Now you’ll use three different skill layers in a real workflow — demonstrating how skills at different abstraction levels compose without conflict.

The Layered Ecosystem

Skills don’t just add capabilities — they operate at different layers of the development process. Understanding these layers helps you choose the right tool and combine skills effectively.

Layer Purpose Example

Harness skills

Shape HOW you work — process, methodology, guardrails

superpowers (brainstorming, TDD, debugging workflows)

Domain skills

Provide WHAT you work with — domain-specific capabilities

conference-toolkit (abstract-writer, conf-finder, trip-report)

Workflow skills

Track WHERE the work stands — state, progress, coordination

beads (issue tracking, dependency management)

The key insight: these layers don’t conflict because they operate at different abstraction levels.

A harness skill tells Claude how to approach a task. It shapes the process: "use TDD" or "brainstorm systematically."

A domain skill gives Claude what to produce: conference abstracts, API clients, documentation.

A workflow skill tracks progress: what’s done, what’s blocked, what depends on what.

When you invoke multiple skills together, Claude resolves them correctly because each operates at its own layer. A /brainstorming session can guide you toward using /conf-finder, and both can update a beads issue — no collision, no confusion.

Setting Up the Layers

Let’s install all three layers.

Install Superpowers (Harness Layer)

Superpowers is an official Anthropic plugin that provides process-oriented skills: brainstorming (structured ideation), TDD (test-first development), and debugging (systematic root-cause analysis).

These are "harness" skills — they shape how you work, not what you build.

claude plugin install superpowers@claude-plugins-official

Initialize Beads (Workflow Layer)

Beads is a Dolt-powered issue tracker that lives in your repository. Issues persist across conversation compaction and session restarts — they’re real data, not ephemeral context.

Create a test project and initialize beads:

mkdir -p ~/capstone-project && cd ~/capstone-project
git init
bd init

This creates a .bd/ directory with a Dolt database. Issues, comments, and metadata are tracked in Git-style versioned tables.

Verify Conference Toolkit (Domain Layer)

You built the conference-toolkit marketplace in Module 4. Confirm it’s installed:

ls ~/.claude/plugins/

You should see conference-toolkit alongside superpowers and any other plugins.

The Landscape

You now have:

  • Harness: superpowers (brainstorming, TDD, debugging)

  • Domain: conference-toolkit (abstract-writer, conf-finder, trip-report)

  • Workflow: beads (issue tracking, dependency management)

Three skill sources, three purposes, zero conflicts.

The Capstone Workflow

Scenario: You’ve been invited to submit a talk to a conference next month. You need to plan it, write it, and track the work.

We’ll use all three layers to complete this from start to finish.

Step 1: Create a Work Item (Workflow Layer)

Start by tracking the work. Create a beads issue:

bd create --title="Submit talk to upcoming conference" --description="Find a relevant conference, write an abstract, submit it" --type=task --priority=2

Beads assigns an ID (e.g., 1). This issue now tracks your progress. You can update it, comment on it, and close it when done — even if the conversation gets compacted or you restart Claude Code.

Step 2: Brainstorm the Topic (Harness Layer)

You have an idea — "something about Agent Skills" — but you need to refine it. Use superpowers to brainstorm systematically:

/brainstorming I want to give a talk about how Agent Skills change the way developers interact with AI coding tools. Help me explore angles and narrow down a focus.

Superpowers will guide you through a structured brainstorming session. It asks clarifying questions:

  • Who’s the audience? (Developers, engineering managers, AI/ML practitioners?)

  • What’s the outcome? (Practical takeaways, conceptual understanding, or both?)

  • What’s the scope? (Intro-level overview or deep-dive implementation?)

As you answer, it proposes angles:

  • "Skills as a new abstraction layer for AI agents"

  • "From prompts to protocols: how skills change the contract"

  • "Teaching AI how you work: process skills vs. domain skills"

You narrow down to: "Agent Skills: Teaching AI How to Work With You" — focusing on the layered ecosystem and real workflow examples.

This is the harness layer in action: superpowers didn’t write code or produce a deliverable. It shaped your process, helping you think clearly and land on a strong angle.

Step 3: Find the Right Conference (Domain Layer)

Now that you have a topic, find a venue. Use the domain layer:

/conference-toolkit:conf-finder Find technology conferences in the next 3 months that accept talks about AI developer tools or AI-assisted coding

The skill searches recent conference listings and returns:

  • AI Dev Summit (2 months out, CFP open, focus: AI-powered development)

  • DevTools Con (3 months out, CFP open, focus: developer productivity)

  • CodeGen Conference (2.5 months out, CFP closed — skip)

You pick AI Dev Summit. The domain layer gave you what you needed: conference options filtered by relevance and timeline.

Step 4: Write the Abstract (Domain Layer)

Time to write. Use the abstract-writer skill you built in Module 3:

/conference-toolkit:abstract-writer Write a full-session abstract about "Agent Skills: Teaching AI How to Work With You" for AI Dev Summit

The skill generates a complete abstract:

  • Hook: "AI coding assistants are powerful, but they don’t know how you work."

  • Promise: "Learn how Agent Skills let you teach AI your process, compose domain capabilities, and track work across sessions."

  • Outline: Introduction to skills, layered ecosystem, live workflow demo, Q&A

  • Takeaways: Practical understanding of skill architecture, examples to start from, confidence to build custom skills

Perfect. Copy it, polish if needed, and paste into the conference submission form.

Step 5: Close the Work Item (Workflow Layer)

The work is done. Close the beads issue:

bd close 1

Replace 1 with the ID from Step 1. The issue moves to closed status. If you run bd ready, it no longer appears in the ready list — the workflow layer knows this work is complete.

Step 6 (Stretch): Generate a Trip Report

After attending the conference, use the trip-report skill you built in Module 4:

/conference-toolkit:trip-report Generate a trip report for AI Dev Summit. Sessions attended: keynote on LLM evals, workshop on agent architecture, panel on AI safety. Key themes: evaluation rigor, production-readiness, human-in-the-loop design.

The skill produces a structured report: summary of sessions, key takeaways, people met, and follow-up actions. Share it with your team or post it internally.

How Skills Compose

Look at what just happened:

  • Three skill sources: superpowers (Anthropic marketplace), conference-toolkit (your marketplace), beads (third-party plugin)

  • Three purposes: process (brainstorming), domain (conference tools), workflow (issue tracking)

  • Zero conflicts: each operated at its own layer

Claude resolved skill activation correctly. When you said /brainstorming, it knew you meant the superpowers harness skill. When you said /conference-toolkit:conf-finder, it knew you meant the domain skill from your marketplace. When you ran bd close, it knew you meant the workflow CLI.

This is the "harness within a harness" concept in action. Superpowers is itself a harness — it provides process scaffolding — running inside Claude Code, which is also a harness. Skills at different layers compose cleanly because they don’t compete for the same role.

The layered ecosystem isn’t theoretical. You just used it to plan a talk, write an abstract, and track the work — all with skills operating at their appropriate levels.

Course Summary

Across five modules, you’ve built a complete mental model of the Agent Skills ecosystem:

Module What You Built

Module 1

Understood what skills are and used a pre-built skill (simple-greeter)

Module 2

Hand-wrote talk-outliner from scratch — learned skill anatomy with a single SKILL.md file

Module 3

Used skill-creator to generate abstract-writer — refined it with templates and supporting files

Module 4

Built conf-finder and trip-report, bundled all three into conference-toolkit marketplace

Module 5

Used three skill layers together (harness + domain + workflow) in a real workflow

You now understand:

  • How skills are structured (prompts, arguments, context)

  • How to write them by hand and generate them with AI

  • How to compose them into marketplaces

  • How skills at different layers work together without conflict

The Agent Skills ecosystem is young. There are opportunities to contribute: build domain-specific skills for your field, share them on public marketplaces, improve tooling like skill-creator, or write harness skills that encode your team’s process.

Module 6 (bonus) covers programmatic skill use — how to invoke skills from code and build automation on top of the skills layer.

You’re ready to build.