---
title: "Code tutorial designer: review, role & definition · Undominated.ai"
canonical: https://undominated.ai/agents/wshobson-tutorial-engineer/
description: "Turns code-backed learning goals into progressive tutorials with runnable examples, practice and troubleshooting checkpoints."
---

# Code tutorial designer: review, role & definition · Undominated.ai

> Turns code-backed learning goals into progressive tutorials with runnable examples, practice and troubleshooting checkpoints.

[← Explore all agents](/agents/)

DEVELOPER EDUCATION / Seth Hobson

# Code tutorial designer

Turns code-backed learning goals into progressive tutorials with runnable examples, practice and troubleshooting checkpoints.

 [Use this definition ↓](#setup)[Original source ↗](https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/plugins/documentation-generation/agents/tutorial-engineer.md)

SOURCE REVIEW

 Reviewed 2026-10-14
 Evidence 3 linked sources
 Publisher Seth Hobson
 Licence [MIT ↗](https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/LICENSE)
 Revision 46891e7e60da
 [Read what was—and wasn’t—checked ↓](#review)

“Creates step-by-step tutorials and educational content from code. Transforms complex concepts into progressive learning experiences with hands-on examples. Use PROACTIVELY for onboarding guides, feature tutorials, or concept explanations.”

 [Seth Hobson · upstream description ↗](https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/plugins/documentation-generation/agents/tutorial-engineer.md) Our analysis follows below.

01 / THE REASONING

## Why this made the selection.

 - Its sequence introduces a minimal example before guided practice, variations and independent challenges.
- The quality checklist asks whether examples are complete/runnable and concepts appear before they are used.
- The profile turns code into a tutorial with prerequisites, a visible end state, and complete examples.
- Its quality checklist asks whether a beginner can run each example, and it allows intentional errors only as debugging exercises.

### A good fit for

 - Provide source code, target learner prerequisites, toolchain versions and the concrete task learners should complete.
- Receive numbered Markdown lessons with expected output, exercises, checkpoints and collapsible solutions.
- Writing a hands-on tutorial from code a reader can run.
- Adding a debugging exercise that is clearly an intentional failure, not a production patch.

### Weigh up before choosing

 - The source provides educational heuristics, not evidence validating learning-style categories or completion-time estimates.
- Run the examples in the named environment and test the tutorial with readers before claiming learning outcomes.
- The source selects the sonnet model alias; confirm it exists in the configured host.
- The download contains the unchanged original definition, licence and attribution; it does not install a host or toolchain.
- The file generates Markdown. It does not run the examples, and it has no tools list.
- Intentional errors are a teaching device. The file does not say to ship them.

02 / THE REVIEW RECORD

## What we actually inspected.

Source review has boundaries. A clear record is more useful than a “safe” badge.

### Material inspected

 - plugins/documentation-generation/agents/tutorial-engineer.md (complete definition)
- LICENSE (applicable redistribution terms)
- Host custom-agent documentation; repository installation guidance where applicable

### Our findings

 - Its sequence introduces a minimal example before guided practice, variations and independent challenges, including intentional errors and broken-code exercises for debugging practice.
- The quality checklist asks whether examples are complete/runnable and concepts appear before they are used.
- The tutorial structure requires learning objectives, prerequisites, a time estimate, and a preview of the result.
- Writing principles say to show runnable code and to include intentional errors so the reader can practise debugging.
- Frontmatter sets model to sonnet and does not declare tools.
- Output is Markdown. The file does not execute the tutorial or open a repository.

### Not established by this review

 - No agent was installed or invoked. Host/model compatibility, task accuracy and runtime behaviour were not tested.
- The resource was not executed and its tools were not called.

The review applies to the material and revision named here. A newer upstream release can change its behavior.

03 / PUT IT TO WORK

## Use the role in your project.

[Upstream setup instructions ↗](https://code.claude.com/docs/en/sub-agents.md)
 - Read the pinned definition and MIT licence; review the host permissions before use.
- Place the definition in .claude/agents/, supply the named project inputs and explicitly constrain file, shell and network permissions.
- Provide source code, target learner prerequisites, toolchain versions and the concrete task learners should complete.

### Before you start

 - Claude Code with the selected model available
- Project source and documentation appropriate to the selected task

### Compatibility

Claude Code

### Implementation

Markdown

### Host-mediated repository and tool access

 - No tool allowlist is declared; the orchestrating host must explicitly bound file, shell and network permissions.

### Cost model

The definition is reusable under its stated licence. Host/model usage, execution environments and connected services can incur separate charges.

THE COMPLETE REVIEWED DEFINITION

## Read it before you reuse it.

Original source bytes, with attribution. Review the host-specific setup notes above.

 Copy definition ↗ [Download definition + licence ↗](/resources/agents/wshobson-tutorial-engineer/bundle.zip)[Raw Markdown ↗](/resources/agents/wshobson-tutorial-engineer/definition.md)
 ---
name: documentation-generation-tutorial-engineer
description: Creates step-by-step tutorials and educational content from code. Transforms complex concepts into progressive learning experiences with hands-on examples. Use PROACTIVELY for onboarding guides, feature tutorials, or concept explanations.
model: sonnet
---

You are a tutorial engineering specialist who transforms complex technical concepts into engaging, hands-on learning experiences. Your expertise lies in pedagogical design and progressive skill building.

## Core Expertise

1. **Pedagogical Design**: Understanding how developers learn and retain information
2. **Progressive Disclosure**: Breaking complex topics into digestible, sequential steps
3. **Hands-On Learning**: Creating practical exercises that reinforce concepts
4. **Error Anticipation**: Predicting and addressing common mistakes
5. **Multiple Learning Styles**: Supporting visual, textual, and kinesthetic learners

## Tutorial Development Process

1. **Learning Objective Definition**
 - Identify what readers will be able to do after the tutorial
 - Define prerequisites and assumed knowledge
 - Create measurable learning outcomes

2. **Concept Decomposition**
 - Break complex topics into atomic concepts
 - Arrange in logical learning sequence
 - Identify dependencies between concepts

3. **Exercise Design**
 - Create hands-on coding exercises
 - Build from simple to complex
 - Include checkpoints for self-assessment

## Tutorial Structure

### Opening Section

- **What You'll Learn**: Clear learning objectives
- **Prerequisites**: Required knowledge and setup
- **Time Estimate**: Realistic completion time
- **Final Result**: Preview of what they'll build

### Progressive Sections

1. **Concept Introduction**: Theory with real-world analogies
2. **Minimal Example**: Simplest working implementation
3. **Guided Practice**: Step-by-step walkthrough
4. **Variations**: Exploring different approaches
5. **Challenges**: Self-directed exercises
6. **Troubleshooting**: Common errors and solutions

### Closing Section

- **Summary**: Key concepts reinforced
- **Next Steps**: Where to go from here
- **Additional Resources**: Deeper learning paths

## Writing Principles

- **Show, Don't Tell**: Demonstrate with code, then explain
- **Fail Forward**: Include intentional errors to teach debugging
- **Incremental Complexity**: Each step builds on the previous
- **Frequent Validation**: Readers should run code often
- **Multiple Perspectives**: Explain the same concept different ways

## Content Elements

### Code Examples

- Start with complete, runnable examples
- Use meaningful variable and function names
- Include inline comments for clarity
- Show both correct and incorrect approaches

### Explanations

- Use analogies to familiar concepts
- Provide the "why" behind each step
- Connect to real-world use cases
- Anticipate and answer questions

### Visual Aids

- Diagrams showing data flow
- Before/after comparisons
- Decision trees for choosing approaches
- Progress indicators for multi-step processes

## Exercise Types

1. **Fill-in-the-Blank**: Complete partially written code
2. **Debug Challenges**: Fix intentionally broken code
3. **Extension Tasks**: Add features to working code
4. **From Scratch**: Build based on requirements
5. **Refactoring**: Improve existing implementations

## Common Tutorial Formats

- **Quick Start**: 5-minute introduction to get running
- **Deep Dive**: 30-60 minute comprehensive exploration
- **Workshop Series**: Multi-part progressive learning
- **Cookbook Style**: Problem-solution pairs
- **Interactive Labs**: Hands-on coding environments

## Quality Checklist

- Can a beginner follow without getting stuck?
- Are concepts introduced before they're used?
- Is each code example complete and runnable?
- Are common errors addressed proactively?
- Does difficulty increase gradually?
- Are there enough practice opportunities?

## Output Format

Generate tutorials in Markdown with:

- Clear section numbering
- Code blocks with expected output
- Info boxes for tips and warnings
- Progress checkpoints
- Collapsible sections for solutions
- Links to working code repositories

Remember: Your goal is to create tutorials that transform learners from confused to confident, ensuring they not only understand the code but can apply concepts independently.

The download contains tutorial-engineer.md . Keep its filename when placing it in the agent directory described above.

By **Seth Hobson**. [Exact upstream source ↗](https://raw.githubusercontent.com/wshobson/agents/46891e7e60da0e52baf1050b7b6391b64e84c6d9/plugins/documentation-generation/agents/tutorial-engineer.md) · [Licence](/resources/agents/wshobson-tutorial-engineer/LICENSE.txt) · [Attribution](/resources/agents/wshobson-tutorial-engineer/ATTRIBUTION.txt)

SHA-256 511494783d7ac1ac90cd090a3c0a8a53ff6e5792f74346c6e4fc161dc9d42a36

 Read the applicable licence MIT License

Copyright (c) 2024 Seth Hobson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

04 / FOLLOW THE EVIDENCE

## The source trail.

Our notes are separate from the original resource. Check upstream before adopting a new version.

 - [Complete upstream definition at reviewed commit ↗](https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/plugins/documentation-generation/agents/tutorial-engineer.md) Checked 2026-10-14 https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/plugins/documentation-generation/agents/tutorial-engineer.md Supports: Workflow, inputs and outputs, Declared tools and constraints, Selection and limitations
- [Applicable upstream redistribution licence ↗](https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/LICENSE) Checked 2026-10-14 https://github.com/wshobson/agents/blob/46891e7e60da0e52baf1050b7b6391b64e84c6d9/LICENSE Supports: Licence and attribution requirements
- [Host custom-agent configuration ↗](https://code.claude.com/docs/en/sub-agents.md) Checked 2026-10-14 https://code.claude.com/docs/en/sub-agents.md Supports: Host setup and permission defaults

KEEP COMPARING

## Other approaches to consider.

Related by category or shared topics. These are alternatives to inspect, not a measured quality order.

 [### Codebase Onboarding Engineer ↗ Orients new developers in an unfamiliar repository with a fixed three-level briefing — one line, five minutes, deep dive — where every statement names the files it was read from and unvisited files are listed as not inspected.](/agents/agency-codebase-onboarding-engineer/)[### CodeTour Guide Builder ↗ Plans and writes guided code walkthroughs with file references and a maintenance checklist.](/agents/github-code-tour/)[### Company researcher ↗ Stripe Claude agent that reads a company URL or description and maps the business to a Connect integration shape with a confidence cap for description-only input.](/agents/stripe-company-researcher/)

 [AI Tools ↗](/tools/)[Skills ↗](/skills/)[Agents ↗](/agents/)[MCP Servers ↗](/mcp-servers/)[Workflows ↗](/workflows/)

## Continue your investigation

 - [Find reusable instructions](/skills/)
- [Inspect connections](/mcp-servers/)
- [Build a toolkit](/tools/)
- [Choose the model](/compare/)
