Claude Slash Commands: Right Format, No Function
This video walks through the five frontmatter fields of a Claude slash command and the ARGUMENTS slot. It shows that matching the format gives only the scaffold, because the reference file produces a template until you write the actual work.
A newcomer building a first slash command often expects that dropping the right file into place means the command already works. The video shows it does not. The reference example that ships with Claude's plugins is a template, not a working command, so the real question becomes what actually makes a slash command run.
What you want from a slash command
The goal is a shortcut: type a slash and a name, maybe a word or two after it, and have Claude do the same specific thing the same way every time. It is easy to assume that once a file exists with the right name and setup, the command already does something. The video calls this the guess most people make when building their first command.
Running the reference file
To test the guess, the video runs the reference example that ships with Claude's plugins. What comes back is a plain template: parse the input, perform the action, report the result. No folder is created, no file is touched, and no action is taken.
The five fields
The top of the file holds five pieces of setup in one short block of text:
- A name.
- A description.
- An argument hint.
- A list of allowed tools.
- A model choice.
The slot that matters most: ARGUMENTS
Whatever you type after the command's name lands, word for word, in a single spot inside the file, a slot called ARGUMENTS. The video's example is typing a greet command followed by a name: the name shows up in that slot exactly as typed. Nothing uses it automatically, though. That part you still write yourself.
What the other fields do
The argument hint is the reminder text a user sees next to the command's name before typing anything, showing the kind of input expected. Allowed tools pre-approves a specific list of tools for this one command, so Claude can use them without asking permission each time, but only for this command. The model field lets the command run on a different model than your default conversation, a faster one for something simple or a stronger one for something needing more reasoning.
The body pattern and the legacy layout
The body follows a three-step shape: parse whatever arrived in ARGUMENTS, perform the actual work, then report what happened. The video notes that this shape is the reference file's own choice, not a rule Claude enforces elsewhere, and that in the reference file the shape is described rather than carried out. There is also an older single-file layout, a commands folder with name.md, which loads exactly the same way. Only the location differs.
Format is not proof, and optional is not broken
The video closes with two directions. Matching the format perfectly does not prove the command does anything real; the reference file matches it exactly and still produces only the template. And skipping an optional field does not mean the command is broken: leave out the argument hint and the command still runs, but users will not see that hint before typing.
Key takeaways
- The reference slash command file is a template, not a working command.
- A command's setup is five fields: name, description, argument hint, allowed tools, and model.
- Whatever you type after the command name goes into the ARGUMENTS slot exactly as typed.
- The argument hint shows expected input before the user types.
- Allowed tools pre-approves tools for that one command only.
- The model field can run one command on a faster or stronger model than the default.
- Parse, perform, and report is this file's own pattern; the parse step is described, but the work is yours to write.
- Matching the format gives the shape, and what happens on running it is still yours to write.
Try it yourself
Ask Claude to build a real slash command called word-count that takes a file path as its required argument, counts the words in that file, and reports the total. Have it show the exact file it would write, then explain in plain terms what ARGUMENTS contains the moment you run it. Try this on your own command idea rather than the video's example.
Chapters
- 0:00The naive framing: "already works, right?"
- 0:10The shortcut you want
- 0:18The wrong guess most newcomers make
- 0:27Break it: running the reference file
- 0:40Five fields
- 0:50The anchor planted: $ARGUMENTS
- 1:03argument-hint
- 1:12allowed-tools
- 1:24model override
- 1:34The body pattern
- 1:46The anchor returns
- 1:57One flag, and the legacy layout
- 2:12Direction A: format isn't proof
- 2:21Direction B: optional isn't broken
- 2:30Carry-out
- 2:41Your turn
- 2:59Outro
Full transcript(auto-generated, with timestamps)
The naive framing: "already works, right?"
[0:00]A newcomer expects that dropping the file in means the command already works. It doesn't. The reference file is a template, not a working command. So, what actually makes a slash command run?
The shortcut you want
[0:10]You want a shortcut, type a slash a name, maybe a word or two after it, and have Claude do the same specific thing the same way every time.
The wrong guess most newcomers make
[0:18]So, it's easy to assume that once a file like that exists, right name, right setup, the command already does something. That's the guess most people building their first one make. Try it,
Break it: running the reference file
[0:28]Run the reference example that ships with Claude's plugins, and here's what comes back, a plain template. Parse the input, perform the action, report the result. No folder created, no file touched, no action taken.
Five fields
[0:40]Underneath the file is five pieces of setup, a name, a description, an argument hint, a list of allowed tools, and a model choice. One short block of text at the top of the file.
The anchor planted: $ARGUMENTS
[0:50]Here's the one that matters most. Whatever you type after the command's name lands, word for word, in a single spot inside the file, a slot called arguments. Type {slash} greet Nick, and Nick shows up there, exactly as typed.
argument-hint
[1:03]The argument hint is what a user sees before they've typed anything at all, the little reminder text next to the command's name, showing the kind of input it's expecting.
allowed-tools
[1:12]Allowed tools do something else entirely. It pre-approves a specific list of tools for this one command, so Claude can use them without asking permission each time, but only for this command, not everywhere.
model override
[1:24]And model lets this one command run on a different model than your default conversation, a faster one for something simple, a stronger one for something that needs more reasoning.
The body pattern
[1:34]The body of the file follows the same three-step shape. Parse whatever arrived in arguments, perform the actual work, then report back what happened. In the reference file, that shape is described, not carried out. So, back to arguments,
The anchor returns
[1:47]Type {slash} greet Nick, and Nick really does arrive, letter for letter, right where the file says it will. What doesn't happen automatically is anything using it. That part, you still write yourself.
One flag, and the legacy layout
[1:57]One flag parse perform report is this file's own chosen shape, not a rule cloud enforces elsewhere. The layout also has an older sibling, a single file command {slash} name.md, which loads exactly the same way. Only the folder differs.
Direction A: format isn't proof
[2:12]So, matching the format perfectly doesn't prove the command does anything real. The reference file matches it exactly, and running it still produces only that template.
Direction B: optional isn't broken
[2:22]And skipping an optional field doesn't mean it's broken, either. Leave out the argument hint, and the command still runs. Users just won't see that hint before they type.
Carry-out
[2:31]Five fields in one slot called arguments are the scaffold of a slash command. Matching the format gets you the shape. What happens when someone actually runs it is still yours to write.
Your turn
[2:41]Your turn. Paste this into Claude. Build me a real slash command called slash word count. It should take a file path as its required argument, count the words in that file, and report the total back to me. Show me the exact skill.md file you'd write for it, and then explain in plain terms what arguments actually contains the moment I run it.
Outro
[2:59]Right format, no function. Lay 'em in for bare.
More from Extending Claude — Skills, Plugins & Connectors
2:07Claude Skills: Write Triggers, Not Topics
2:04Saved Isn't Live: the Discord Plugin's Configure Skill
2:44Claude Plugin Hooks: Only Four of the Nine Events Work Here
2:13Claude Slash Commands: Written for Claude, Not for You
2:23Onboard an M5Stack Board With One Claude Command
1:56