●CC 2.1.325 — No new release over the weekend; 2.1.325 (11/13) is still the latest●BILLING — 2.1.325 fixes background sessions on a claude.ai login being billed to an API key from the shell●SONNET 4.5 — Retires on the Claude API on 11/30, 14 days left. Check saved model settings too●403 — Users report a Cloudflare 403 page mid-session that still burns tokens●MANAGED — Since 11/12 you can request self-hosted Claude Managed Agents that run entirely on your own infrastructure●NEW — When Browser Extension Is Not Connected Won't Go Away●CC 2.1.325 — No new release over the weekend; 2.1.325 (11/13) is still the latest●BILLING — 2.1.325 fixes background sessions on a claude.ai login being billed to an API key from the shell●SONNET 4.5 — Retires on the Claude API on 11/30, 14 days left. Check saved model settings too●403 — Users report a Cloudflare 403 page mid-session that still burns tokens●MANAGED — Since 11/12 you can request self-hosted Claude Managed Agents that run entirely on your own infrastructure●NEW — When Browser Extension Is Not Connected Won't Go Away
Composing Claude Code Skills — Building Automation a Single Skill Can't Reach
A practical guide to going beyond one-skill-at-a-time and composing multiple Claude Code Skills into real workflows. Pipeline, branching, and meta-skill patterns with full implementation examples and the failure modes you should design against.
"I wrote the hooks. I built the skills. And yet, when the work gets complex, I'm still hand-walking Claude through each step." If you've started using Claude Code Skills seriously, this feeling probably sounds familiar. For a long time I felt the same way. Each SKILL.md I shipped felt like a win, but real work — generating an image, writing the markdown, producing the PDF, logging the result — only completes when several pieces chain together. Getting past the single-skill ceiling requires composition.
This guide is about turning Claude Code Skills from "tools you use one at a time" into "components you compose into automation." We'll cover the principles, the three patterns I've found durable in production, and the failure modes that quietly break composed pipelines.
The moment a single skill stopped being enough
I noticed the limit when I tried to put my entire app-release routine — icon generation, screenshot creation, release-note authoring, Stripe product upload, and per-platform social posts — into one SKILL.md. The frontmatter description ballooned to cover all five jobs, and as a result Claude stopped triggering it reliably. The semantic distance between any one user request and that overloaded description became too large.
Skills are loaded based on a meaning-level match between your message and the skill's description. The more roles you stuff into one skill, the less likely any specific message will be close enough to fire it. That was a useful lesson:
Personal takeaway: A skill should be sized so that "the unit Claude loads" matches "the unit of work it does." Bigger skills are harder, not easier, to call.
In other words, skills should be intentionally small, and large work should emerge from composition. That's the starting point for everything else in this guide.
The three mechanisms that make composition possible
Skill composition isn't magic. It's three existing Claude Code behaviors used together.
The conversation context persists. After skill A loads, skill B can still load later in the same conversation if a follow-up message matches its description.
Skills can invoke other skills. If skill A's body says "for this next step, call the xlsx skill," Claude will obey, using the Skill tool to load the next one.
The filesystem is shared memory. Intermediate files written by skill A become inputs for skill B, without touching the conversation context budget.
Underneath all three is how skills load in the first place. At startup, only each skill's name and description enter the conversation; the body of a SKILL.md is read only when that skill is actually invoked (checked against the official Extend Claude with skills page, November 2026). That's why a shelf of small skills costs you very little until one of them is called.
Whenever a skill composition feels broken, I've found that one of these three things is being violated. A SKILL.md written without composition in mind usually drops a hint that it expects to be the only skill running.
✦
Thank you for reading this far.
Continue Reading
What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.
WHAT YOU'LL LEARN
✦Move past the 'one skill, one task' ceiling and chain skills together so a single conversation completes multi-stage work end to end
✦Apply three concrete composition patterns — pipeline, conditional branching, and meta-skill — with working SKILL.md examples for each
✦Avoid the four failure modes that quietly break composed skills (loops, overlapping descriptions, path drift, bloated orchestrators) before they reach production
Secure payment via Stripe · Cancel anytime
✦
Unlock This Article
Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.
The simplest pattern is a pipeline of skills run in order.
.claude/skills/image-generator/SKILL.md
---name: image-generatordescription: Generates an OGP image from a description and saves to /tmp/og.png---Input: text description of the imageOutput: /tmp/og.png (1200x630, PNG)When done, return the file path in chat.**If the user wants the image embedded in a blog post next, the `markdown-writer` skill can take over.**
.claude/skills/markdown-writer/SKILL.md
---name: markdown-writerdescription: Writes a blog post markdown file from an image and a topic outline---Precondition: /tmp/og.png exists.Output: a .md file at the path the user specifies.Embed the image at the top of the file using ``.
Two details matter here. First, skill A's body explicitly mentions a possible handoff to skill B. Claude reads this text and uses it to volunteer skill B when the user follows up. Second, skill B declares its preconditions — if A ever changes its output path, B fails loudly instead of silently producing wrong output.
The payoff is that A and B remain independently testable. You can ask "make me an OGP image" and only A runs. You can hand B a different image and it still works. Composition is the user's choice, not a forced coupling.
Pattern 2: Conditional branching
In real workflows, the next step often depends on what was produced. App-icon assets need an ASO uploader; blog OGPs need a publishing skill. Conditional branching solves this without adding code.
.claude/skills/asset-router/SKILL.md
---name: asset-routerdescription: Routes a generated image asset to the correct downstream skill based on its dimensions and intended use---Input file: /tmp/asset.pngRouting rules:- 1024x1024 square → app icon → invoke `aso-uploader`- 1200x630 or other landscape → blog OGP → invoke `blog-publisher`- Otherwise → ask the user which use case applies, then route accordinglyAlways log "decision: <rule> → <next skill>" in one line before invoking the next skill.
The key insight is to express routing logic as prose in the SKILL.md, not as code. Code couples the routing rule to a runtime, while prose lets you add or modify rules with a text edit. My personal rule of thumb: if a future version of me, three months from now, can read the rule and understand the intent, prose wins. If precision and replay matter (e.g., regulated environments), reach for code.
Pattern 3: Meta-skills (skill-of-skills)
When a workflow has five or more steps, a coordinating skill — a meta-skill — pays off.
.claude/skills/new-release-orchestrator/SKILL.md
---name: new-release-orchestratordescription: Coordinates the full app-release workflow: icons, screenshots, release notes, store update, social posts---This skill is a coordinator. It does not perform the work itself; it sequences other skills.Step 1: `app-icon-generator` → /tmp/icon.pngStep 2: `store-screenshot-generator` → /tmp/screens/Step 3: `release-notes-writer` → /tmp/release.mdStep 4: `aso-uploader` → store updatedStep 5: `social-post-composer` → /tmp/social/{platform}.txtAfter each step, verify the output file exists before proceeding.If a precondition fails, stop and emit the missing path.End with either "all_steps_completed" or "stopped_at_step_N".
The discipline here is that the meta-skill owns no business logic — only sequencing, precondition checks, and stop conditions. "How to make the icon" lives entirely in app-icon-generator. This lets you swap individual steps freely. If a better icon-generation skill ships next month, you replace one skill and the meta-skill keeps working untouched.
I learned the next lesson the uncomfortable way. During the first week with an orchestrator, Claude picked it up the moment I mentioned "the new version" in passing, and started drafting a release announcement I hadn't reviewed yet. Nothing shipped, but it was not a pleasant morning. Since then, any orchestrator that touches something hard to undo — a store update, a social post — gets disable-model-invocation: true in its frontmatter. Claude will no longer decide to run it on its own; it runs only when I type /new-release-orchestrator.
---name: new-release-orchestratordescription: Runs a new app release in order — images, store update, release notes, social postsdisable-model-invocation: true---
Let the skill remember the order; let me decide when it runs. The more you compose, the more that line earns its keep.
The three patterns versus forked execution — which to pick when
There's a fourth option alongside the three patterns. Adding context: fork to a skill's frontmatter runs it in an isolated subagent context, without the main conversation's history. The agent field picks which kind of agent runs it — for example the read-oriented Explore (also per the official docs).
---name: research-collectordescription: Takes a topic and writes primary-source URLs and notes to /tmp/skill-pipeline/<run-id>/research.mdcontext: forkagent: Explore---Do not paste findings into the conversation. Write them to research.md.Finish by returning the absolute path of that file on one line.
Forking a step that reads dozens of pages means the main conversation only gets back a summary and a file path. The next skill, outline-builder, reads the file rather than the chat, so it doesn't miss the history.
Approach
Fits when
How state moves
Avoid when
Pipeline
Two or three steps always run in the same order
One intermediate file
The next step depends on what was produced
Conditional branching
The output type decides the next step
A one-line routing log plus the file
You can't state the routing rule in a sentence
Meta-skill (orchestrator)
Four or more steps, with conditions to stop
A fixed-path JSON manifest
There are only two steps
context: fork
Heavy reading you don't want in the main conversation
Only a summary and a path come back
The step relies on what was just said in the chat
If I had to compress the choice into one sentence: keep steps that depend on the conversation in the same context, and fork only the heavy steps that don't. When I'm unsure, I check whether every input to that step can be handed over as a file. If it can, it can be forked. If it can't, it's safer to leave it in the conversation.
Sharing context — where state lives between skills
Skills exchange information in three ways:
Conversation history (implicit). Short text outputs flow naturally; Claude remembers what the previous skill said.
Intermediate files in /tmp (explicit). Anything binary, large, or worth inspecting lives in files. This is my default.
A persistent manifest (durable). A fixed JSON like /tmp/release-state.json survives across longer multi-stage workflows.
I default to intermediate files for two reasons. First, long sessions truncate older conversation history, so relying on Claude's memory is fragile. Second, files give me an inspectable seam between skills. When the pipeline breaks, I can cat /tmp/draft.md and see exactly what was handed over.
# A timestamp-rooted intermediate directory keeps parallel runs from clobbering each othermkdir -p /tmp/skill-pipeline/$(date +%Y%m%d-%H%M%S)
Once you start running multiple compositions in the same day, that timestamp prefix saves you from a particularly painful kind of debugging.
Four failure modes — and how to design against them
Within the first few weeks of composing skills, you will hit each of these. Build the prevention in from day one.
Failure 1: Skills that loop into each other
If A's body says "next, call B" and B's body says "when finished, call A", Claude can ping-pong between them.
Fix: Whenever a skill mentions invoking another, condition it on a fresh user request. Auto-handoff is acceptable only in one-direction pipelines, never in cycles.
Failure 2: Overlapping descriptions
A "write Markdown" skill and a "write a blog post" skill will both compete when a user says "write me a blog post in Markdown." Selection becomes unstable.
Fix: Phrase descriptions as role-noun + concrete I/O. Replace "writes Markdown" with "writes a technical article to /tmp/post.md." Specificity restores deterministic selection.
Failure 3: Path drift between skills
Skill A writes to /tmp/og.png. Skill B looks at /var/tmp/og.png. Silent failure.
Fix: Write a single shared path convention document (e.g., _documents/SKILL_PIPELINE_PATHS.md) and have every skill cite it in its first paragraph. Future skills inherit the convention.
Failure 4: Bloated meta-skills
Once a coordinator starts including "how to do step 3," it grows back into the monolithic skill you were trying to escape.
Fix: Cap meta-skills at 120 lines. If you exceed it, the overflow belongs in a child skill. I picked 120 from experience: above that, contributors stop reading the orchestrator carefully and start guessing, which is exactly when subtle ordering bugs slip in. Pick a limit that fits your team's attention span and enforce it.
A concrete example: a four-skill blog-writing pipeline
Here's the composition I actually use for blog drafting. Four small skills plus an orchestrator, instead of one bloated SKILL.md.
.claude/skills/research-collector/SKILL.md
---name: research-collectordescription: Given a topic, collects primary references and notes into /tmp/research.md---Input: topic (free text)Output: /tmp/research.md with H2 sections "References", "Key Points", "Audience"Include at least three first-source links. Bullets must be facts, not opinions.
.claude/skills/outline-builder/SKILL.md
---name: outline-builderdescription: Builds an article outline at /tmp/outline.md from research.md---Input: /tmp/research.md (precondition)Output: /tmp/outline.md with an H1 candidate, 5–7 H2 candidates, and bullet points per H2H2s must reflect "what the reader wants to know," not feature names.Order H2s along the reader's learning path.
.claude/skills/draft-writer/SKILL.md
---name: draft-writerdescription: Writes the full draft to /tmp/draft.md from outline.md, target 6,000+ words---Input: /tmp/outline.md (precondition)Output: /tmp/draft.md (warm voice, at least one code example, problem-driven intro)Forbidden opening lines: "In this article, we will explore...", "Let's take a look at...".Begin from a concrete reader problem instead.
.claude/skills/quality-checker/SKILL.md
---name: quality-checkerdescription: Scans draft.md for AI-tells and templated phrasing, writes findings to /tmp/review.md---Input: /tmp/draft.mdOutput: /tmp/review.md with line numbers, findings, and suggested rewritesFlag clichés like "In conclusion", "we hope you found this helpful", "let's dive in".Flag any "as an AI" or generic recap paragraph as critical.
And the orchestrator that runs them:
.claude/skills/blog-orchestrator/SKILL.md
---name: blog-orchestratordescription: Runs the full research → outline → draft → review pipeline for a blog post---Order:1. `research-collector` (topic → research.md)2. `outline-builder` (research.md → outline.md)3. `draft-writer` (outline.md → draft.md)4. `quality-checker` (draft.md → review.md)5. If review.md flags 3+ critical findings, re-invoke `draft-writer` for a revision pass.After each step, confirm the target file exists and is non-empty before continuing.On completion, return the final draft.md path in chat.
The benefit becomes obvious the first time you want to swap something. When a better research tool ships, you replace research-collector only. When your style guide evolves, you edit quality-checker only. With a monolithic SKILL.md, every change is a rewrite of the whole thing.
Testing and debugging — keeping composed skills observable
When a composed pipeline breaks, the question is always "which skill failed, and why?" Three habits make this easy.
Per-skill minimal test inputs
Each skill ships with a tiny canonical input under _skill_tests/{skill-name}/input.md, and the SKILL.md says "to verify this skill in isolation, use this input file." Now you can validate any single piece without dragging the whole pipeline along.
By telling Claude in each SKILL.md to write this format on completion, you get a single timeline of the whole composition. When something goes wrong, tail /tmp/skill-pipeline.log tells you exactly where it stopped.
A --check dry-run mode in the orchestrator
Add a clause to the meta-skill: "if invoked with --check, do not execute any step; only verify that preconditions and paths align." Run this before any high-stakes pipeline execution. It catches configuration drift before it ruins a release.
A judgment call: Skill composition is a tool for going faster with fewer mistakes, not faster at the cost of stability. The moment you have three skills feeding each other, observability stops being optional.
When a composed pipeline stalls — a triage table
With a shared log, you'll know where it stopped almost immediately. The harder question is why. These are the symptoms I've actually hit, in the order I check them.
Symptom
Likely cause
How to check
Fix
The next skill never gets called; the conversation just ends
The hand-off sentence has no condition, or the next skill has disable-model-invocation: true
Look at /skills and at the last line of the log
Name the next skill explicitly; if it's meant to be run by a person, say /name in the steps
A skill runs, then stops with "file not found"
Path drift or a mismatched run-id
ls the run directory and compare the log's input and output paths
Keep one path ledger and have every skill refer to it
The same skill fires again and again
A and B both hand off to each other automatically
Look for the same skill name repeated in the log
Keep automatic hand-offs one-directional; make the return trip "only if the user asks"
A skill starts on an unrelated message
The description is too broad or overlaps another skill
Check which message it fired right after
Narrow the description to "role noun + inputs and outputs"; make side-effecting orchestrators manual
After adding more skills, one that used to fire no longer does
The description listing exceeded its budget and got truncated
Read the startup warning and the /skill-doctor report
Remove skills you don't use; put the key words at the start of each description
A forked skill comes back with shallow results
It assumed context from the earlier conversation
Check whether all of its inputs exist as files
Write what it needs to a file before calling it, or keep it in the same context
Rows one and five look identical from the outside, yet the causes are entirely different — one is how the skill is written, the other is how crowded the shelf is. Mix them up and you can rewrite the description all afternoon without fixing anything.
Three common misconceptions, checked against the docs
"Adding skills means every SKILL.md is loaded every time." Per the official docs, only names and descriptions are loaded at startup; bodies load on invocation. The descriptions themselves, though, are always present, and that listing has a budget (the docs mention it can be adjusted with the SLASH_COMMAND_TOOL_CHAR_BUDGET environment variable). What grows with every skill you add is the listing, not the bodies.
"I can put a note or heading above the frontmatter." Frontmatter starts with the --- on the very first line of the file. Anything placed before it risks the frontmatter not being read at all. That's why the examples in this guide name the file path outside the code block.
"An orchestrator calls its sub-skills like functions." Whether a skill gets invoked is ultimately Claude's call. Where you need certainty, write precondition checks and stop conditions in plain language, and keep steps that are hard to undo behind a manual /name invocation.
The next wall — taking stock once the shelf fills up
Once composition starts working, the next thing you'll run into is sheer count. Splitting skills small means a fuller shelf, similar descriptions side by side, and one day a skill that simply stops being picked. At that point I stopped judging skills by body size and started looking at which sections were actually read; that process is in The Biggest Section in Your SKILL.md Is Usually the One to Keep, and the day I counted unused and duplicate skills is written up in I counted 42 skills on my shelf.
Steps that should fire on a file change or a tool call belong to hooks rather than skills. If all you want is a log line at the end of a composed run, the PostToolUse section of A Field Guide to the 8 Core Hooks is the shortest path.
Refactoring a monolithic skill into a composed pipeline
Many readers will already have a large SKILL.md they want to break apart. Below is the four-phase refactor I actually use. Doing it in phases — rather than rewriting in one pass — is what keeps the workflow intact while you change it.
Phase 1: Trace the responsibility boundaries
Read the existing SKILL.md and list every verb in its body: "generate the image," "upload it," "write markdown," "log results." Then group verbs by shared inputs and outputs. "Make and save image" and "edit a saved image" belong in different groups. The number of groups becomes your target skill count.
This sounds trivial, but it surfaces hidden coupling. The first time I did this for my release pipeline, two operations I thought belonged together turned out to share no inputs at all — they were neighbors only by accident.
Phase 2: Define shared paths and a manifest first
Before splitting any logic, decide the paths each future skill will read and write, and document them. Skipping this step is the single most common reason refactors stall: each new skill invents its own path, and the integration phase becomes a manual diff exercise.
# _documents/SKILL_PIPELINE_PATHS.md (write this first, before splitting)- Image artifact: /tmp/skill-pipeline/<run-id>/asset.png- Research notes: /tmp/skill-pipeline/<run-id>/research.md- Final deliverables: /tmp/skill-pipeline/<run-id>/final/
This document becomes the contract. Every new skill cites it. Whenever a skill needs a new shared file, you update the contract first, not the skill.
Phase 3: Split from the tail end, one skill at a time
Extract the last step of the workflow into its own SKILL.md (e.g., "log the result"). Add a minimal test input. From the original monolithic skill, delete that block and replace it with a single sentence: "next, invoke the xxx skill." Run end to end, confirm it still works, then move on to the next tail step.
Working from the tail end minimizes ripple effects. If you start at the entry point, the still-monolithic downstream code makes assumptions that break under partial extraction. The tail has no downstream to surprise.
Phase 4: Extract the orchestrator
When the original SKILL.md only contains "ordering, precondition checks, and stop conditions," it's already a meta-skill. Promote it: rename it to *-orchestrator, clean up the descriptions of the steps, and you're done.
A practical tip from doing this badly first: After extracting one skill, run the pipeline once. Don't queue up three extractions and validate them together. The whole point of the phased approach is that each phase has a known-good baseline; collapsing phases removes the safety net.
The cost angle — does composition really save tokens?
A reasonable concern: more skills means more SKILL.md content potentially pulled into context. Doesn't that increase token cost? In my experience it tends to go the other way, and here's why.
Only the bodies you need are loaded. A body is expanded when its skill is invoked, so five small skills don't put five bodies into context — only the ones in use. A single bloated SKILL.md, by contrast, brings in the instructions for every step the moment it fires, even for a simple case.
Intermediate files don't consume conversation tokens. Passing a multi-page research note via /tmp/research.md keeps the bulk of the content out of the message history. Claude reads precisely what the next skill needs, not the entire previous output.
Retry costs are bounded. When a monolithic skill fails halfway, restarting it consumes the entire pipeline's tokens again. With composition, you re-run only the failing skill. For long workflows this is the difference between a minor rerun and a full-cost replay.
# A simple way to track skill sizes and pick monsters to split firstfor f in ~/.claude/skills/*/SKILL.md; do echo "$(wc -c < "$f") bytes $f"done | sort -n
Token use per conversation swings a lot depending on how you measure and what the task was, and I don't have a comparison I'd trust, so I won't quote a percentage here. What I actually look at in that output is the skill whose body is long while only part of it gets used on any given run. That one is the first candidate to split.
There's a secondary benefit that isn't strictly about cost but is worth naming: debugging time goes down, too. With one skill, "why did it produce this?" requires re-reading hundreds of lines. With composed skills, the trail of intermediate files lets you read the exact moment the pipeline diverged. The savings on engineer time often dwarf the savings on tokens.
If you want a sharper picture of the actual cost difference, instrument it for a week. After each composed run, append the response's usage.input_tokens and usage.output_tokens (visible via the Anthropic SDK or the Claude Code log) to a CSV alongside the same metric for the equivalent monolithic run. Two weeks of real workload tells you more than any abstract analysis. Expect short tasks to be the exception, since the orchestrator's own instructions can outweigh what it saves — that's the kind of nuance you only see by measuring.
One more practical note. When using prompt caching with composed skills, place the orchestrator's static instructions and the consistently-loaded child skill descriptions inside a cache breakpoint. Because skill loading is conversation-scoped, a long-running session with the same orchestrator hits the cache repeatedly, dropping per-turn cost meaningfully. This is one of those cases where composition and caching reinforce each other rather than fight.
When you should not compose — cases where monolithic is right
Composition is a tool, not a doctrine. Not every SKILL.md should be split. Three signals tell me to keep something as a single skill.
The work always runs in the same order with the same preconditions. A skill like "lint, spellcheck, and format the README" doesn't branch and doesn't depend on prior outputs in interesting ways. Splitting it produces three nearly identical SKILL.md files and a meta-skill that just lists them. You've added complexity without buying flexibility. When the steps are stable, the savings of composition disappear and the maintenance cost stays.
There's no meaningful state to pass between steps. Composition shines when intermediate files become useful debugging artifacts. If your pipeline only passes short strings or numbers, the file-based handoff is overhead without payoff. A single skill keeps the whole flow legible in one place. The decision is essentially: "would I want to inspect this intermediate file at 2 a.m.?" If no, you don't need a file, and you probably don't need composition.
The work is one-off, project-specific, and won't be reused. Composition pays for itself when components get reused across workflows. If a skill exists to handle a single quirky requirement of a single project, the abstraction tax outweighs the benefit. Write it as one skill, ship the project, and move on.
I've come to ask one question before splitting any new SKILL.md: "Will I plausibly want this piece to combine with a different skill in the next three months?" If the honest answer is "no," I write a single skill and don't apologize for it. Composition is about reuse, extensibility, and testability — and those need to actually be needed, not assumed. Some of my most reliable skills have stayed as monoliths for over a year because they hit a sweet spot of stability and isolation. Knowing when not to compose is just as much a part of good Skill design as knowing when to do it.
A useful counter-test: imagine a junior teammate who has never seen your skill ecosystem. If they ask "why are these split?" and you can give a one-sentence answer about reuse, branching, or testability, the split is earning its keep. If you find yourself describing the original problem instead, you split too early.
I'll close this section with a confession: I split too early on my first major composition project, and the cleanup took weeks. The pieces were technically correct but conceptually arbitrary, which made the system harder to reason about, not easier. The lesson stuck — composition has to be motivated by an actual force of change, not by a general aesthetic preference for "small things." Wait until you can name the force, then split. The line between "appropriately decomposed" and "scattered" is thinner than most posts about software design admit.
A first move you can make today
You don't need to adopt every pattern at once. The single most useful first step is chaining two existing skills with Pipeline composition. Add one sentence to skill A's body suggesting skill B as a follow-up. Add one sentence to skill B's body declaring A's output path as a precondition. Run a small workflow end to end. That's enough to feel why composition pays off.
When you reach a third skill, introduce a meta-skill. Three is the threshold where a human can no longer reliably hold the sequence in their head, and where a coordinator starts earning its place.
Skill composition is closer to assembling a small specialist team than to building a single generalist. A team of three good specialists who hand off cleanly will outperform one overloaded expert almost every time. Pick one SKILL.md you wrote last month, and add a single line about which skill should run next. That's the doorway.
A final thought worth sitting with: the leverage from composition compounds. The first chained pair you build saves a few minutes of orchestration. The fifth saves entire afternoons because the pieces snap together in combinations you didn't originally plan for. That compounding only happens if each individual skill is small enough to recombine. So when you're choosing between "make this skill do one more thing" and "extract that thing into its own skill," remember that the second option is buying you optionality. Most of the value comes later, in workflows you haven't thought of yet, executed by future-you who will quietly thank present-you for keeping the pieces small.
Share
Thank You for Reading
Claude Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.