In April, Anthropic quietly merged custom slash commands into the skills system. Files in .claude/commands/ still work — nothing broke — but the recommended path now is .claude/skills/<name>/SKILL.md, with frontmatter that controls who invokes the command (you, Claude, or both), which tools it pre-approves, and whether it forks into its own subagent context. If you've been treating slash commands as keyboard shortcuts, you've been working a level below where the system actually lives.
What follows are ten I run. Half are utilities. Half are doctrine in disguise. The line between the two is the point.
1. /dispatch
The seed. Takes a Gemini deep research dump, kicks off a longform draft, hands the result back for the Triple Transformation pipeline.
---
name: dispatch
description: Convert a research artifact into a Lewis-style longform draft
argument-hint: [research-file] [angle]
allowed-tools: Read Write
---
Read $1 and produce a publication-ready longform piece on $2.
Lead with a scene. Bury the thesis at the 60% mark.
End with a turn that re-frames the opener.
The reason this earns its keep isn't speed. It's that the constraint set — lead with a scene, bury the thesis, end on a turn — is encoded once and applied forever. Every dispatch comes out structurally consistent because the prompt is structurally consistent.
A note on the name. Anthropic shipped a feature called Dispatch in Cowork last quarter — you message a task from your phone and your desktop spawns a session to handle it. Ethan Mollick wrote about it at the end of March: an interface that feels less like a chatbot and more like talking to a competent assistant, the closest thing yet to AI as a personal agent rather than a text box. That's not what /dispatch does in my library. Mine is a publishing skill named after the GemClaw Dispatch series — it converts research artifacts into Lewis-style drafts, not phone messages into desktop tasks. Their Dispatch dispatches work to your machine. Mine dispatches drafts to my readers. The verb is the only shared surface, and the collision is the point: .claude/skills/ is a namespace I govern, not Anthropic. Yours is too.
2. /ship
Stage, commit, push. The lowest-friction command on the list and the one that pays back fastest.
---
name: ship
description: Stage, commit, and push the current change
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *) Bash(git push *) Bash(git status *)
---
## Current state
!`git status --short`
!`git diff --stat`
Write a conventional-commits message for the staged changes, then commit and push.
Note disable-model-invocation: true. You don't want the model deciding to push because the code "looks ready." Side effects need explicit triggers.
3. /redteam
Fork an Explore agent, hand it the artifact, and let it attack. This is the command that catches the scrivener errors before the recipient does.
---
name: redteam
description: Adversarial review of the current artifact
context: fork
agent: Explore
argument-hint: [path-to-artifact]
---
You are reviewing $1 with the explicit job of finding errors,
unsupported claims, and weak inferences. Be uncharitable.
For each finding return: location, severity, suggested fix.
Forking matters here. A red-team running in your main context inherits your assumptions. A forked agent reads cold. Different output.
4. /handoff
Most context loss happens at session boundaries. /handoff writes the bridge.
---
name: handoff
description: Generate a handoff document for the next session
allowed-tools: Read Write
---
Produce a handoff document containing:
1. What was decided this session, with the reasoning
2. Open questions and the options on the table
3. Files touched and why
4. The next concrete action
Save it to handoffs/${CLAUDE_SESSION_ID}.md.
${CLAUDE_SESSION_ID} is one of the substitutions skills give you for free. The handoff folder becomes a session log without you ever writing one on purpose.
5. /skill
The recursive one. Convert the current session into a SKILL.md. Once you've solved a problem twice by hand, the third solve should be a skill.
---
name: skill
description: Capture the current workflow as a new skill
argument-hint: [skill-name]
---
Review this conversation and produce a SKILL.md for "$1" that
encodes the procedure I just performed. Output the file at
.claude/skills/$1/SKILL.md. Include argument-hint and the
minimal allowed-tools needed.
The first time you run /skill to make a skill that makes skills, you'll feel the loop close. That feeling is the right one.
6. /9x16
Triple Transformation step three. Take a longform draft, return a JSON spec for a 9×16 infographic.
---
name: 9x16
description: Convert a longform draft into 9x16 infographic JSON
argument-hint: [draft-path]
---
Read $1. Extract 7-9 panels. For each panel produce:
{ "panel": int, "headline": str, "supporting_stat": str | null,
"visual_motif": str, "callout_quote": str | null }
Output a single JSON array. No prose around it.
The "no prose around it" line is doing more work than it looks. Without it, you get apologetic preambles every time and your downstream parser breaks.
7. /errata
Publish enough and you'll need this. The corrections workflow you wish you'd built before you needed it.
---
name: errata
description: Generate a v2 errata notice for a published artifact
argument-hint: [artifact-id] [correction-summary]
---
## Recent commits
!`git log --oneline -10`
Produce an errata notice for $1 covering: $2.
Format: short cover note, original text, corrected text,
date, version increment. Match the tone of the original artifact.
Bash injection on git log lets the model see what actually changed instead of guessing. That's the difference between an errata that names the right commit and one that hand-waves.
8. /portal
If you run a client portal — even a lightweight one — this command turns an artifact into a portal entry.
---
name: portal
description: Push the current artifact to the client portal
argument-hint: [artifact-path] [client-id]
allowed-tools: Read Write Bash(curl *)
---
Read $1. Generate metadata: title, summary (2 sentences),
tags, classification, recommended-action. Write to
portal/$2/incoming/ as JSON. Don't include the artifact body —
just the metadata payload.
The discipline here is keeping payload and metadata separate. Skills that conflate the two produce JSON files that quietly become unparseable when the artifact has a curly brace in it.
9. /lineage
Now we leave the utility belt. /lineage takes a founder or researcher's name and traces the load-bearing thread from their training to the company they built.
---
name: lineage
description: Trace the architectural lineage of a founder's company
argument-hint: [name]
---
Trace $1's intellectual lineage: doctoral training, advisor,
dissertation thesis, the central frame they carried out.
Then map that frame onto the architecture of the company
they founded or now lead. Identify the load-bearing claim
that survived the transition. Cite sources.
This is the command that converts a thesis into an instrument. Every time you run it you're applying Architectural Determinism — the claim that founders' doctoral priors are load-bearing infrastructure in their companies' AI architectures — to a specific case. Run it on Hassabis and you get the SCT-to-world-models thread. Run it on Kaplan and you get the AdS/CFT-to-Constitutional-AI isomorphism. The command isn't illustrating the doctrine. It's instantiating it.
10. /jam
The Substack made operational. Take a doctrinal claim, stress-test it against three counter-frames, return where it holds and where it cracks.
---
name: jam
description: Stress-test a claim against three counter-frames
argument-hint: [claim]
---
Take this claim: $ARGUMENTS
Generate three serious counter-frames from disjoint domains
(historical, technical, sociological). For each, articulate
the strongest version of the objection. Then identify where
the original claim survives intact, where it must be narrowed,
and where it fails. No bothsidesing — pick a verdict.
End with the rewritten claim, narrowed appropriately.
This is the Context Jamming method, encoded. If a claim can't survive /jam, it shouldn't ship.
The doctrine underneath
The reason this list ends with /lineage and /jam and not, say, /lint is that what you choose to compress reveals what you actually do. A slash-command library is a public commitment device. Build /ship and you've decided shipping is a bottleneck. Build /redteam and you've admitted that your first drafts need an enemy. Build /lineage and you've declared that founders' training is load-bearing — which means anyone who reads your library now knows what you believe about how AI architectures get made.
This is not a metaphor. The skills you commit to .claude/skills/ and check into version control become legible artifacts of your operating doctrine. A new collaborator reading them learns more about how you actually work in five minutes than they would from a CLAUDE.md essay you wrote about how you work.
So the question isn't "what slash commands should I copy from this post." The question is: if someone audited your .claude/skills/ directory next week, what would they conclude you actually do?
The honest answer to that is the only thing this list is really about.
If you build any of these, send them. I'll publish the best community variants in the next dispatch.