Slash Command or Skill? When to Use Each in Claude Code

July 24, 2026 · Claude Certified Architect (CCA) Prep (part 28)

▶ Watch on YouTube & subscribe to The Stack Underflow

You built a PDF-parsing routine last month — a script, a couple of reference files, and a page of instructions on how to use them together. It worked. Now you want Claude Code to reach for it automatically whenever a task actually involves a PDF, without you typing a shortcut every time and without cluttering every single prompt with instructions for a capability you use twice a week. Where does that live? The instinct is to reach for the same tool that made /review work — but a slash command and the thing you actually need solve two different problems, and mixing them up is exactly the kind of question Domain 3 of the Claude Certified Architect exam tests.

The one-sentence version: A slash command is a shortcut you invoke by name; an Agent Skill is a packaged, multi-file capability the model invokes on its own, only when the task makes it relevant.

The question

You want to package a multi-file capability (scripts + instructions) the model reaches for when it’s relevant — not something you type on demand. What is that?

• A) A slash command
• B) An Agent Skill (a SKILL.md folder)
• C) A CLAUDE.md note
• D) A permission rule

Pause here and pick an answer before you scroll — the reasoning matters more than the letter.

The answer

B — an Agent Skill, packaged as a SKILL.md folder.

The distinguishing fact is who decides to invoke it. A slash command is a shortcut a human types — you know it exists, you know when you need it, you type /review and it runs. A Skill is discovered and invoked by the model itself, based on the task at hand, without you naming it. That single difference — invoked by you vs. invoked by the model — is the entire mechanism behind this question, and it’s why “multi-file capability + the model reaches for it when relevant” can only describe a Skill.

THREE WAYS TO PACKAGE A CAPABILITY

┌─────────────────────────┐   ┌─────────────────────────┐   ┌─────────────────────────┐
│  SLASH COMMAND           │   │  AGENT SKILL             │   │  CLAUDE.md              │
│  .claude/commands/*.md   │   │  SKILL.md folder         │   │  always-on context      │
│                           │   │                           │   │                           │
│  Invoked by: YOU          │   │  Invoked by: THE MODEL    │   │  Loaded: EVERY session   │
│  Trigger:   you type      │   │  Trigger:   task looks    │   │  Trigger:   always, in   │
│    /name                  │   │    relevant to it         │   │    every prompt          │
│  Files:     one .md file  │   │  Files:     scripts +     │   │  Files:     one .md file │
│                           │   │    reference docs +       │   │                           │
│                           │   │    SKILL.md, progressive  │   │                           │
│                           │   │    disclosure             │   │                           │
└─────────────────────────┘   └─────────────────────────┘   └─────────────────────────┘
        ↑ shortcut                    ↑ this question               ↑ constant context

The phrase “progressive disclosure” is doing real work in that diagram. A Skill’s SKILL.md file holds a short description that Claude reads up front — cheap, always in context. The rest of the Skill (scripts, longer reference docs, examples) only gets pulled in if Claude decides the task actually needs it. That’s what makes Skills a good home for multi-file capabilities: you can bundle as much supporting material as the task requires without paying the context-window cost on every unrelated turn. A slash command has no such structure — it’s a single markdown file that gets read fully the moment you invoke it, because you already decided it’s relevant by typing its name.

Why the other options fail

• A) A slash command — Tempting because it also “packages” a workflow, and it can even reference multiple files internally. But a slash command exists in .claude/commands/*.md and runs only when you explicitly type /name. It has no mechanism for the model to notice on its own that a task matches it. If you’re not there to type it, it never fires — which contradicts “the model reaches for it when relevant.”
• C) A CLAUDE.md note — CLAUDE.md is always-on context: every line loads into every session regardless of whether the current task needs it. That’s the opposite of selective, on-demand invocation. It’s also not a place to bundle scripts or multi-file assets — it’s prose instructions, not a packaged capability with its own files.
• D) A permission rule — Permission rules live in settings.json and govern whether a tool call is allowed, asked-about, or denied. They gate behavior that’s already happening; they don’t package a capability or decide when the model reaches for a set of scripts and docs. Completely different layer of the system.

The concept behind it

Zoom out and Claude Code’s configuration surface breaks into a small number of mechanisms, each answering a different question:

The exam-relevant pattern is that each row trades off who decides and how much gets loaded. CLAUDE.md is maximal certainty (it’s always there) but maximal cost (it’s always there, on every turn, whether needed or not). A slash command is zero ambient cost but requires you to remember it exists. A Skill sits between the two: near-zero ambient cost (just the short description in SKILL.md), triggered automatically, with the heavier files pulled in only on demand. That’s the specific tradeoff that makes Skills the right answer whenever a question describes a capability that’s (1) multi-file, (2) meant to be discovered rather than remembered, and (3) not needed on every single turn.

A useful gut-check for exam questions in this shape: ask “does a human have to know this exists and type something to trigger it?” If yes, you’re looking at a slash command. If the scenario instead says the model should “notice,” “reach for,” or “use when relevant,” that’s the Skill signature — and if it further says “guaranteed, no matter what the model decides,” that’s actually a hook, a different mechanism covered in the CLAUDE.md-vs-hooks comparison below. Keeping these three trigger types straight — you-invoked, model-invoked, harness-invoked — resolves most of Domain 3’s configuration questions without needing to memorize file paths at all.

FAQ

Can a Skill call a slash command, or vice versa? They’re not designed to call each other directly — they’re two separate invocation paths into the same underlying agent. A slash command expands into a prompt you triggered; a Skill is content the model pulls into its own context when it judges the task relevant. In practice a project might have both: a /deploy command for a human-triggered release flow, and a Skill for something like “generate accessible alt text,” which Claude should reach for any time an image is involved, without anyone remembering to ask for it.

Do Skills replace CLAUDE.md? No — they solve different problems. CLAUDE.md is for context that should shape every response (coding conventions, project structure, team norms). A Skill is for a bounded, occasionally-needed capability with its own supporting files. Cramming a multi-file capability into CLAUDE.md bloats every single session’s context; cramming always-relevant conventions into a Skill means the model might not always decide to load them. Use each for what it’s built for.

Where do project Skills live versus personal ones? The same shared-vs-personal split shows up here as it does for commands and settings: project-level Skills live under the repo so the whole team gets them, while personal ones live under your user-level Claude Code directory and follow you across projects. Verify the exact current path in Anthropic’s Claude Code docs, since Domain 3 tracks live product behavior that can shift.

Is “the model reaches for it when relevant” the same as function calling or tool use? Related but not identical. Tool use is the model calling a defined function with structured parameters mid-conversation. A Skill is a higher-level packaging concept — it can bundle tools, scripts, and reference docs together, and part of what makes it “relevant” is often that its description matches the current task well enough for Claude to decide to load it. Think of a Skill as a capability folder the model can choose to open, not a single function signature.

Not affiliated with, authorized, or endorsed by Anthropic. “Claude” and “Claude Certified Architect” are trademarks of Anthropic. These are original practice questions for study, not real exam content — verify current exam details on Anthropic’s official pages.

Where this fits in the CCA series

This is Domain 3 territory — Claude Code Configuration & Workflows, roughly 20% of the exam (verify the current weighting and exam logistics — Pearson VUE, $125, retakes, 60 questions in 120 minutes, pass at 720/1000 across five domains — on Anthropic’s official pages). It sits right next to Where Does a /review Shortcut Live? Claude Code Slash Commands, which covers the other half of the you-invoked-vs-model-invoked split in more depth, and Instructions or a Hook — Which Runs Every Time? CLAUDE.md vs Hooks, which covers the third trigger type — the harness-guaranteed one. If you haven’t nailed down where team conventions actually belong, start with Where Does a Team Convention Live? Project CLAUDE.md Explained. For the full five-domain map this question sits inside, see the Claude Certified Architect (CCA) Exam Guide. Browse all tutorials for the rest of the series.