diataxistutorial

name

diataxis:tutorial

description

Use when the user asks for a tutorial, beginner walkthrough, getting-started lesson, first-project guide, or onboarding material for new users. Creates learning-oriented step-by-step lessons where readers learn by doing something meaningful. The goal is skill and confidence, not task completion. Do not use for advanced tasks, troubleshooting, or exhaustive product coverage — those are how-to guides.

Tutorial writer

Purpose

Create a true tutorial: a learning-oriented lesson in which the reader learns by doing something meaningful.

This is not a how-to guide. The aim is not to help an already-competent user complete a task, but to help a learner build skill and confidence.

When to use

Use this skill when the user asks for:

• a beginner walkthrough
• a getting started lesson
• a first project
• onboarding material for new users

Do not use this skill for troubleshooting, advanced tasks, operational runbooks, or exhaustive product coverage.

Tutorial promise

A tutorial should say, in effect:

"Stay with me, follow these steps, and you will successfully build or do something concrete."

The author is responsible for the learner's path and success.

Key principles

• learning-oriented, not task-oriented
• concrete actions, not abstraction
• visible results early and often
• clear expected outcomes at each step
• minimal explanation
• no unnecessary options or alternatives
• strong reliability and testability

Structure

Use this shape:

1. Title focused on the thing the learner will make or achieve
2. What we are going to build or do
3. Prerequisites kept minimal
4. Step-by-step lesson
5. Checkpoints with expected results
6. Short recap of what the learner now has
7. Next steps linking to how-to, reference, and explanation

Writing rules

Start with a concrete destination

State what the learner will accomplish, not what they will "learn".

Good:

• In this tutorial, we will build a small Kotlin client that fetches weather data.

Bad:

• In this tutorial, you will learn about networking, architecture, and design.

Deliver visible results early

Get to a meaningful output quickly.

Every step should create an observable result:

• a command succeeds
• a UI changes
• a file appears
• a request returns data
• a test passes

Maintain expectation

Tell the learner what should happen next.

Use language like:

• You should now see...
• The output should look like...
• If you do not see..., check...

Minimise explanation

Only explain just enough for the step to make sense. Move conceptual depth into explanation pages.

Remove choices

Choose defaults for the learner. Do not branch unless absolutely necessary.

Favour confidence over coverage

A shorter tutorial that works is better than a broad tutorial that overwhelms.

Inputs to gather

• exact learner starting point
• one meaningful end result
• minimal prerequisites
• stable environment assumptions
• commands, files, and outputs that can be tested
• known failure points

Output contract

Produce a tutorial that:

• is safe for a beginner to follow
• works as written on the chosen happy path
• includes expected outputs or checkpoints
• resists distraction
• hands off naturally to deeper docs

Anti-patterns to remove

• long conceptual detours
• option matrices
• exhaustive flags and parameters
• advice for advanced users
• hidden prerequisites
• steps without observable outcomes

Final self-check

Before returning, verify:

• the tutorial has one achievable goal
• every step has a reason to exist
• the learner gets a result early
• the likely failure points are anticipated
• explanation is ruthlessly trimmed
• the ending points to the next appropriate docs