Home > Tasks > Writing > TutorialGeneration

TutorialGeneration

An industrial-grade tutorial engine that transforms complex goals into structured, multi-phase educational content with automated validation and troubleshooting.

Category: Writing Output: tutorial.md Auto-Fix: Supported

⚙️ ExecutionConfig.json

{
  "goal": "Setup a CI/CD pipeline with GitHub Actions",
  "target_platform": "GitHub / Linux",
  "skill_level": "advanced",
  "target_step_count": 6,
  "include_validation_steps": true,
  "include_next_steps": true
}

→

👁️ SessionTask UI ● Running

Overview

Outline

Complete Tutorial

Tutorial: CI/CD with GitHub Actions

Estimated Time: 60 minutes

Step 1: Create Workflow File

Create .github/workflows/main.yml:

touch .github/workflows/main.yml

✓ Validation: File exists in workspace

Step 2: Add Hosting...

Test Workspace Browser

Explore generated artifacts (tutorial.md, transcript.md) in the task workspace.

Field	Type	Description
goal *	String	The final outcome the user should achieve (e.g., 'deploy a web app to the cloud').
target_platform	String	Environment context (Windows, Linux, Docker, etc.). Default: `"cross-platform"`.
include_screenshots_placeholders	Boolean	Add `[Screenshot...]` placeholders where visuals are needed. Default: `true`.
verbosity	String	Level of detail: `concise`, `detailed`, `verbose`. Default: `"detailed"`.
include_troubleshooting	Boolean	Whether to generate a common errors section. Default: `true`.
skill_level	String	Target audience level: `beginner`, `intermediate`, `advanced`. Default: `"beginner"`.
estimated_duration	Int	Estimated time to complete in minutes. Default: `30`.
include_code_examples	Boolean	Include code blocks and CLI commands. Default: `true`.
include_validation_steps	Boolean	Include steps to verify success. Default: `true`.
include_learning_objectives	Boolean	Include a "What You'll Learn" section. Default: `true`.
include_next_steps	Boolean	Include a "Next Steps" section. Default: `true`.
target_step_count	Int	Number of main steps (3 to 20). Default: `7`.
input_files	List<String>	Optional glob patterns for source code context (e.g. `*/.kt`).

Phase 1: Planning

Generates a TutorialOutline including prerequisites, learning objectives, and step-by-step purpose mapping.

Phase 2: Writing

Iteratively writes each TutorialStep, injecting code blocks, validation logic, and platform-specific commands.

Phase 3: Hardening

Compiles TroubleshootingSection and NextSteps to ensure the user isn't left at a dead end.

Embedded Execution (Headless)

To run this task programmatically using the UnifiedHarness:

val harness = UnifiedHarness(serverless = true)
harness.start()

val config = TutorialGenerationTaskExecutionConfigData(
    goal = "Setup a CI/CD pipeline",
    skill_level = "advanced",
    target_step_count = 5
)

harness.runTask(
    taskType = TutorialGenerationTask.TutorialGeneration,
    executionConfig = config,
    workspace = File("./my-project")
)

Test Case Example

Example of a validated configuration for automated testing:

// Test: Generate a concise Docker tutorial
val testConfig = TutorialGenerationTaskExecutionConfigData(
    goal = "Containerize a Spring Boot app",
    target_platform = "Docker",
    verbosity = "concise",
    include_troubleshooting = false,
    input_files = listOf("pom.xml", "src/main/resources/application.properties")
)

val validationResult = testConfig.validate()
if (validationResult == null) {
    // Proceed with execution
}

Prompt Segment

TutorialGeneration - Create complete, step-by-step tutorials for processes and projects
** Specify the goal or final outcome to achieve
** Define target platform and environment
** Set skill level and estimated duration
** Enable screenshot placeholders for visual guidance
** Configure verbosity level (concise, detailed, verbose)
** Include code examples and commands
** Add validation steps to verify success
** Include troubleshooting section for common errors
** Add learning objectives and next steps
** Produces publication-ready tutorial with clear, actionable steps