Skills do not call other skills. A SKILL.md file is an instruction document, not executable code. It cannot programmatically invoke another skill, spawn a subprocess, or trigger an external event. What a skill can do is instruct Claude to take those actions. The distinction matters: the skill defines what Claude should do; Claude is the entity that actually does it.
TL;DR: A Claude Code skill cannot programmatically call another skill or spawn a subagent on its own. A skill can contain instructions telling Claude to invoke a related skill by name, or to use Claude Code's Task tool to spawn a subagent. Claude then follows those instructions. The skill is the instruction; Claude is the executor.
How does Claude use multiple skills in one session?
When Claude Code starts a session, it reads the description of every SKILL.md file in the skills directory. It stores these descriptions in memory. When a user request arrives, Claude evaluates which skill descriptions match the request and activates the relevant skill.
The full skill body only loads when the skill activates: in a typical session, all skill descriptions together occupy fewer than 100 tokens in context, less than 0.1% of Claude's 200k-token context window (ClaudeFast context analysis, 2025).
Multiple skills can activate in a single conversation if the user's requests match multiple skill descriptions. A developer might start a session, trigger a code review skill with one request, then trigger a documentation generation skill with a follow-up request. Both skills activate in sequence without the developer explicitly naming them.
At AEM, we design skill libraries around this behavior. A content production library might contain four skills: one for drafting, one for tone review, one for SEO checking, and one for final formatting. Claude activates each in response to the developer's requests as the workflow progresses. The skills do not orchestrate each other; Claude orchestrates all of them based on the descriptions (source: AEM commission analysis, 2026, internal skill library design documentation).
Can a skill explicitly instruct Claude to invoke another skill?
Yes. A SKILL.md can contain an instruction like: "After completing this draft, remind the user to invoke the /review skill for quality checking." Claude reads this instruction and, at the appropriate step in the workflow, follows it. The instruction must be explicit: vague handoff language produces inconsistent behavior, while precise trigger conditions produce reliable cross-skill invocation.
This is instruction-based invocation, not programmatic invocation. The skill is not calling the other skill directly. The skill is telling Claude to tell the user to invoke the other skill, or to invoke it on their behalf, depending on how the instruction is phrased.
A more direct version: "When this step is complete, activate the [skill-name] skill by matching the request context." This works if the review skill's description is broad enough to match what Claude generates at that step. It fails if the review skill's description requires a specific invocation pattern.
"When you give a model an explicit output format with examples, consistency goes from around 60% to over 95% in our benchmarks." — Addy Osmani, Engineering Director, Google Chrome (2024)
The same principle applies to cross-skill invocation. If the handoff instruction is explicit and the receiving skill's description matches precisely, the sequence is reliable. Vague handoffs produce inconsistent behavior.
Can a skill instruct Claude to spawn a subagent?
Yes, with caveats. Claude Code provides a Task tool that lets Claude spawn subagents: separate Claude instances that execute tasks in parallel or in sequence. A skill can contain instructions telling Claude to use this tool. The spawning instruction in the skill must specify the subagent's prompt, expected output format, and how results should be returned to the main workflow.
Example instruction in a SKILL.md:
Step 4: Use the Task tool to spawn a subagent with this prompt: "Review [output from step 3] for security vulnerabilities. Return a structured report of findings."
When Claude reads this instruction and reaches step 4, it uses the Task tool to spawn the subagent as instructed. The skill defined the requirement. Claude executed it.
The caveat: this requires that Claude Code's Task tool is available in the current session and that the user's permissions allow subagent spawning. Not all Claude Code configurations have this enabled. Check the tool registry for your setup before building a skill that depends on it. Subagents also benefit from a clean context: research shows performance degrades significantly when models must retrieve instructions placed in the middle of long input contexts, with accuracy highest when key instructions appear at the start or end (Nelson Liu et al., Stanford NLP Group, "Lost in the Middle," 2023, ArXiv 2307.03172).
For context on when this multi-agent pattern makes sense versus a single well-designed skill, see When Does a Workflow Need Multiple Agents vs a Single Skill?.
When should a skill instruct Claude to spawn a subagent?
Spawn a subagent when the workflow contains a task that runs in parallel with the main workflow, or when the subtask warrants an isolated context. The two reliable cases are parallel verification, where the subagent checks output without seeing the generation context, and large-scale information retrieval, where the subtask would consume a disproportionate share of the main context.
Two cases where subagent spawning inside a skill makes sense:
- Parallel verification: The main skill produces output and the subagent independently verifies it. Both can run simultaneously, saving time compared to sequential verification.
- Isolated evaluation: A subagent evaluating quality needs a clean context to avoid bias from the generation context. The generation skill spawns a fresh subagent with only the output to evaluate.
In most cases, a single well-structured skill handles both generation and verification without spawning anything. At AEM, fewer than 15% of production skills use subagent spawning. The other 85% handle their complete workflow in a single skill context. When parallel execution does apply, Anthropic's guidance confirms that running independent subagents concurrently reduces wall-clock time materially: searches, tool calls, and intermediate reasoning no longer bottleneck each other (Anthropic, "Building Effective Agents," December 2024).
"The single biggest predictor of whether an agent works reliably is whether the instructions are written as a closed spec, not an open suggestion." — Boris Cherny, TypeScript compiler team, Anthropic (2024)
Adding a subagent to a skill that does not need one makes the workflow harder to debug, slower to execute, and more expensive to run. The single-skill default is almost always correct.
What is the practical difference between skill chaining and multi-agent architecture?
Skill chaining: Claude activates skill A, follows its instructions, produces output, then activates skill B in response to the next request. Both skills run in the same Claude Code session. The context from skill A is available when skill B executes.
Multi-agent architecture: Claude A runs skill A and spawns Claude B to run a separate task. Claude B has its own context, which may or may not include Claude A's output depending on how the spawning instruction is written.
For most workflows, skill chaining in a single session is simpler, cheaper, and more reliable. The context from previous steps is automatically available. No coordination overhead, no API calls to manage subagent results. Multi-agent architectures use roughly 10-15x more tokens than equivalent single-agent workflows, which makes cost a real constraint for frequent, short-cycle tasks (Anthropic multi-agent research system analysis, 2025).
Multi-agent architecture becomes worth the overhead when:
- The subtask is so large it would crowd the main task's context
- The subtask needs to run without influence from the main task's context (true evaluation isolation)
- The subtask can run in parallel, saving wall-clock time
For a guide to making this architectural choice, see When Should I Use a Subagent Instead of a Skill?.
What does skill composition look like in practice?
In practice, a multi-skill workflow chains skills sequentially through description matching: Claude activates each skill in response to the developer's request at each stage, using trigger conditions written into each SKILL.md to determine the correct handoff point. No explicit orchestration code is needed. The following three-skill content production workflow illustrates the pattern:
- Draft: trigger: "draft a [content type] about [topic]"; output: complete first draft; final instruction: "Draft complete. Invoke the /review skill for quality checking."
- Review: trigger: requests containing a draft document and a quality-checking context; output: structured feedback; final instruction: "Review complete. Apply approved changes, then invoke /format for final output."
- Format: trigger: requests containing reviewed content and formatting context; output: formatted final document.
Claude handles the sequencing. The developer's workflow:
- Submit a draft request
- Receive the draft
- Submit a review request
- Receive feedback
- Submit a format request
- Receive final output
Three requests. Three skill activations. No explicit skill invocation commands required if the descriptions are written correctly.
This is the production bar at AEM: skills that compose naturally through description matching, without requiring the user to manage the sequence manually. As Simon Willison noted, each skill adds only "a few dozen extra tokens" to context at discovery time, with full details loading only when the skill activates: the description index is cheap enough to hold dozens of skills without degrading session performance (Simon Willison, 2025).
Frequently Asked Questions
Skills do not call each other directly, but they share context within a session and can instruct Claude to hand off between them. The questions below address the practical edge cases: context inheritance, description conflicts, session limits, subagent context isolation, and when a single skill is sufficient for a multi-step workflow.
Can a skill read the output of another skill? Yes, if the skills run in the same Claude Code session. All output from previous exchanges is available in the context window when the next skill activates. A skill that runs after another skill can reference and build on what the previous skill produced.
Can two skills conflict with each other if their descriptions overlap? Yes. If two skill descriptions both match the same request, Claude may activate the wrong one or attempt to apply both simultaneously. Resolve this by tightening the trigger conditions so each skill description matches a distinct class of request. See What Causes Multiple Skills to Interfere with Each Other? for the diagnostic process.
Is there a limit to how many skills can be chained in one session? Practical context window limits apply. Each skill's output adds to the session context. A long chain of skills, each producing substantial output, can consume the context window before the final skill executes. This is an argument for keeping individual skill outputs concise and structured.
Can a skill spawn a subagent that uses a different skill? Yes. The spawning instruction in the main skill can include the full prompt for the subagent, including which skill to invoke or what instructions to follow. The subagent does not automatically inherit the parent skill's context unless you explicitly pass it in the spawning prompt.
Do I need multiple skills for a multi-step workflow? Not necessarily. A single skill can contain a multi-step workflow with branching logic, quality checks, and complex output contracts. Multiple skills are beneficial when each step is independently useful, reusable in other contexts, or complex enough to warrant its own description and trigger conditions.
Last updated: 2026-05-06