Claude, Documentation.
The video explains that when you ask Claude to write documentation, a SKILL.md file rather than a mood decides the shape. The skill recognizes five document types, returns the same sections in the same order for each, and makes no promise outside that list.
Ask Claude to document something and the expected result is a free-form write-up, shaped however Claude thinks fits. The video argues the opposite: the shape of the document comes from a file, not a mood. Using a request for a runbook as its example, it explains how the documentation skill fixes the sections in advance and where that guarantee stops.
What decides the contents of a document
The video's example request is to write a runbook for restarting the payment service. It asks what actually decides what that document contains. The natural guess is that Claude drafts it the way a person would, improvising sections and picking whatever length feels right. If that were true, asking for the same runbook on another day would produce a different result each time.
The same sections in the same order
According to the video, nothing drifts. Ask for the same runbook again and the same three sections come back in the same order: prerequisites, steps and rollback. The reason given is that a file decided them, not a mood. That is the central claim of the video, and the example request is the phrase it asks viewers to hold on to.
A skill is a folder with one file
The documentation skill is a folder Claude reads before it writes. Inside is a single file, SKILL.md, containing the instructions in plain language. The video says the file does not cover just any writing. It names five specific shapes, each with its own trigger phrase:
- README
- runbook
- onboarding guide
- API docs
- architecture docs
How the skill runs
The skill works in order: read SKILL.md, execute the matching steps and return the finished document. There is no improvising. The video describes the process as linear for the most part, and says the file branches only when a step itself says so, never on a whim. Because the runbook request named a shape the file already knows, the same sections come back each time. A generated runbook, README or API doc in a named shape is the promised shape delivered, which the video treats as real signal.
Where the guarantee ends
If you ask for something the file does not name, such as some ad hoc write-up outside its list, the guarantee ends. You are then back to Claude's general judgment rather than the specification. The video also carefully limits its claims: it does not say five shapes is the right scope for a documentation skill, it does not say every skill works this way, and it does not say a document in a named shape is complete or accurate, only that its shape matches what the file promised.
The prompt shown at the end
The closing prompt asks Claude, before it writes the runbook, to say exactly what SKILL.md tells it to include, namely the shape and the phrase that triggers it. Then the viewer asks for the same shape twice and compares. The video suggests watching whether Claude names the shape and its sections before writing a word, and whether the second draft matches the first.
Key takeaways
- The structure of a document Claude writes under this skill comes from a SKILL.md file, not from improvisation.
- A skill is a folder Claude reads before it writes, and this one holds a single plain-language file.
- The skill recognizes five shapes: README, runbook, onboarding guide, API docs and architecture docs.
- Each shape has its own trigger phrase, so naming the shape matters.
- A runbook request returns the same sections, prerequisites, steps and rollback, in the same order.
- The process is read, execute, return, and branches only when a step says so.
- Outside the five named shapes, the guarantee ends and Claude falls back to general judgment.
Try it yourself
Pick a document you need, such as a runbook for a service you maintain, and use the video's prompt. Ask Claude to read the documentation SKILL.md and state the shape, its sections and the trigger phrase before it writes. Request the same shape twice and compare the two drafts to see whether the sections and their order match.
Chapters
- 0:00Claude, document this — just write whatever sounds good, right?
- 0:10Before it writes, something decides what the document contains
- 0:17The guess: freeform draft, improvised sections
- 0:24Ask again — same sections, same order, every time
- 0:32A skill is a folder: one file, SKILL.md
- 0:41Anchor planted — write a runbook for restarting the payment service
- 0:48Five shapes the file recognizes
- 0:54How the skill works: read, execute, return
- 1:02Linear, mostly — branches only when a step says so
- 1:07Anchor payoff — same runbook, same shape
- 1:15A named shape delivered is real signal
- 1:21Outside the list, the guarantee ends
- 1:30Carry-out: name the shape, get the shape
- 1:39Your turn
- 1:51Outro
Full transcript(auto-generated, with timestamps)
Claude, document this — just write whatever sounds good, right?
[0:00]Someone asks Claude to document this, expecting a free-form write-up shaped however Claude feels fits. Wrong. The shape comes from a file, not a mood. So, what decides it? You ask Claude to write
Before it writes, something decides what the document contains
[0:10]A runbook for restarting the payment service. Something decides what that document actually contains. The natural
The guess: freeform draft, improvised sections
[0:17]Guess, Claude drafts it like a person would, improvising sections and picking whatever length feels right. Ask for
Ask again — same sections, same order, every time
[0:24]That same runbook again another day. Nothing drifts, the same sections, same order, because a file decided them, not a mood. That's because documentation is
A skill is a folder: one file, SKILL.md
[0:33]A skill, a folder Claude reads before it writes. Inside sits one file, skill.md, the instructions in plain language. Say
Anchor planted — write a runbook for restarting the payment service
[0:41]The request is, write a runbook for restarting the payment service. Hold on to that exact phrase. The file doesn't cover just any writing.
Five shapes the file recognizes
[0:49]It names five specific shapes, each with its own trigger phrase. Then it works in order, read skill.md,
How the skill works: read, execute, return
[0:56]Execute the matching steps, return the finished document. No branching, no improvising. Linear mostly, the file only branches
Linear, mostly — branches only when a step says so
[1:03]When a step itself says so, never on a whim. Back to that runbook, the same three
Anchor payoff — same runbook, same shape
[1:08]Sections come back in the same order, because the request named a shape the file already knows. A generated runbook, readme, or API doc
A named shape delivered is real signal
[1:17]Is real signal. The named shape it promised delivered. But ask for
Outside the list, the guarantee ends
[1:21]Something the file doesn't name, some ad hoc write-up outside its list, and the guarantee ends there. You're back to Claude's general judgment, not the specs. A skill is a recipe Claude reads
Carry-out: name the shape, get the shape
[1:32]Before it writes, not a mood it improvises. Name a shape the file recognizes, and that's exactly what you get. Your turn. Here's the prompt, read
Your turn
[1:40]It with me. Ask Claude, before you write this runbook, tell me exactly what skill.md says you'll include, the shape and the phrase that triggers it. Then ask for the same shape twice and compare.
Outro
[1:51]Claude documentation. Lay 'em in for bear.





