diataxis-and-doc-types
Diátaxis splits documentation into four modes along two axes: **practical vs theoretical** (doing vs knowing) and **study vs work** (acquiring skill vs applying it). Each mode answers a different reader question. Mixing them is the single most common documentation failure.
$ npx -y skills add vanara-agents/skills --agent claude-codeHow it fires
How this agent gets triggered: by you, by Claude, or both.
- Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
- You can call itInvoke it directly when you want it.
Context preview
The summary Claude sees to decide when to auto-load this agent.
Diátaxis splits documentation into four modes along two axes: **practical vs theoretical** (doing vs knowing) and **study vs work** (acquiring skill vs applying it). Each mode answers a different reader question. Mixing them is the single most common documentation failure.
Agent definition
diataxis-and-doc-types.mdDiátaxis and the four doc types
Diátaxis splits documentation into four modes along two axes: **practical vs theoretical** (doing vs knowing) and **study vs work** (acquiring skill vs applying it). Each mode answers a different reader question. Mixing them is the single most common documentation failure.
The four quadrants
| Type | Reader's question | Mode | Posture | |---|---|---|---| | **Tutorial** | "Teach me, I'm new." | learning / doing | Hand-holding, linear, builds confidence | | **How-to guide** | "Help me do X." | working / doing | Goal-first, assumes competence | | **Reference** | "What is the exact behavior of Y?" | working / knowing | Dry, exhaustive, consistent | | **Explanation** | "Why does it work this way?" | learning / knowing | Discursive, gives context and trade-offs |
Decision table
Pick the type from the reader's *intent*, not the subject matter:
| If the reader wants to… | Write a… | |---|---| | Get a first win and learn by doing | Tutorial | | Accomplish a specific, known task | How-to guide | | Look up a flag, field, signature, or value | Reference | | Understand a concept, decision, or trade-off | Explanation |
Tell-tale signs of a blended (broken) doc
- A "getting started" page that pauses to enumerate every config option → tutorial leaking into reference.
- A how-to that stops to explain the underlying theory → how-to leaking into explanation. Link instead.
- A reference page with a friendly narrative arc → reference leaking into tutorial. References are lookup
tables, not stories.
- An explanation page with copy-paste steps → split the steps into a how-to.
Per-type skeletons
**Tutorial** — linear, every step succeeds, no choices to make: 1. Promise a concrete outcome ("by the end you'll have a running X"). 2. List prerequisites once, up front. 3. Numbered steps, each producing visible progress. 4. Show expected output after each meaningful step. 5. End with what they built and where to go next.
**How-to guide** — goal-first, assumes competence (see `examples/how-to-example.md`):
- One-line goal → prerequisites → steps → verify → rollback/troubleshooting.
**Reference** — exhaustive and *consistent* (see `examples/reference-example.md`):
- Every entry uses the same structure (name, type, default, description, example).
- Alphabetical or grouped, never narrative. Optimized for scanning and `Ctrl-F`.
**Explanation** — discursive, makes trade-offs explicit:
- State the question, give context, walk through alternatives, explain why this choice, note the costs.
- No step lists; this is prose for understanding, not doing.
Cross-linking strategy
Keep each doc single-purpose and connect them:
- Tutorials link *out* to how-tos and references for "more detail."
- How-tos link to explanations for "why," and to references for exact values.
- References link to explanations for concepts and to how-tos for tasks.
- Explanations link to how-tos so a convinced reader can act.
Read more
Diátaxis and the four doc types
Diátaxis splits documentation into four modes along two axes: **practical vs theoretical** (doing vs knowing) and **study vs work** (acquiring skill vs applying it). Each mode answers a different reader question. Mixing them is the single most common documentation failure.
The four quadrants
| Type | Reader's question | Mode | Posture | |---|---|---|---| | **Tutorial** | "Teach me, I'm new." | learning / doing | Hand-holding, linear, builds confidence | | **How-to guide** | "Help me do X." | working / doing | Goal-first, assumes competence | | **Reference** | "What is the exact behavior of Y?" | working / knowing | Dry, exhaustive, consistent | | **Explanation** | "Why does it work this way?" | learning / knowing | Discursive, gives context and trade-offs |
Decision table
Pick the type from the reader's *intent*, not the subject matter:
| If the reader wants to… | Write a… | |---|---| | Get a first win and learn by doing | Tutorial | | Accomplish a specific, known task | How-to guide | | Look up a flag, field, signature, or value | Reference | | Understand a concept, decision, or trade-off | Explanation |
Tell-tale signs of a blended (broken) doc
- A "getting started" page that pauses to enumerate every config option → tutorial leaking into reference.
- A how-to that stops to explain the underlying theory → how-to leaking into explanation. Link instead.
- A reference page with a friendly narrative arc → reference leaking into tutorial. References are lookup
tables, not stories.
- An explanation page with copy-paste steps → split the steps into a how-to.
Per-type skeletons
**Tutorial** — linear, every step succeeds, no choices to make: 1. Promise a concrete outcome ("by the end you'll have a running X"). 2. List prerequisites once, up front. 3. Numbered steps, each producing visible progress. 4. Show expected output after each meaningful step. 5. End with what they built and where to go next.
**How-to guide** — goal-first, assumes competence (see `examples/how-to-example.md`):
- One-line goal → prerequisites → steps → verify → rollback/troubleshooting.
**Reference** — exhaustive and *consistent* (see `examples/reference-example.md`):
- Every entry uses the same structure (name, type, default, description, example).
- Alphabetical or grouped, never narrative. Optimized for scanning and `Ctrl-F`.
**Explanation** — discursive, makes trade-offs explicit:
- State the question, give context, walk through alternatives, explain why this choice, note the costs.
- No step lists; this is prose for understanding, not doing.
Cross-linking strategy
Keep each doc single-purpose and connect them:
- Tutorials link *out* to how-tos and references for "more detail."
- How-tos link to explanations for "why," and to references for exact values.
- References link to explanations for concepts and to how-tos for tasks.
- Explanations link to how-tos so a convinced reader can act.
🐒 Free agents, skills & packs for Claude Code One subscription. An army of Claude Code agents. 30 production-grade agents, skills, and packs for Claude Code — free, Apache-2.0, install with one command.
Repo: vanara-agents/skills
Other agents on vanara-agents-skills.
- AGENT
Use when designing a new HTTP/GraphQL API or changing an existing one — modeling resources, defining endpoint contracts, choosing status codes, pagination, filtering, error envelopes, versioning, and idempotency. Produces a reviewable API contract plus an OpenAPI snippet, not
Open agent - review-notes
This shows how the api-designer agent reviews a flawed draft. Findings are severity-ranked so the implementer fixes the contract-breakers first. Severity legend: **CRITICAL** (breaks clients / data risk), **HIGH** (real bug or inconsistency), **MEDIUM** (maintainability),
Open agent - contract-and-openapi
The contract is the deliverable. Express it as an **OpenAPI 3.1** document so it is human-readable *and* machine-checkable. This reference covers how to structure that document and what `scripts/lint-openapi.mjs` enforces.
Open agent - design-checklist
Run through this before declaring an API contract done. It is ordered the way you should *design*: resources first, cross-cutting rules last. Every box is a place real APIs go wrong in production.
Open agent - versioning-and-evolution
APIs are forever once published: a consumer you've never met may depend on any field you expose. Design so you can **add without breaking**, and version explicitly when you must break.
Open agent - pr-comment-template
Copy-paste templates for leaving review comments. Keep each comment to one finding: an anchor, the problem, and the fix.
Open agent

