Views: 1
In the world of corporate and technical documentation, information decay is rapid. A project manager drafts a sprawling, 3,000-word document outlining a new process. A week later, a new employee needs to execute the process. They don’t need a document; they need an SOP (Standard Operating Procedure) or a Tutorial. They need a clean, sequential guide—a checklist—that tells them exactly what to click, when, and why.
The gap between the source material (the What and the Why) and the executable instruction (the How) is the greatest time sink in knowledge transfer. Analysts spend hours manually dissecting narrative text, identifying implicit dependencies, and structuring linear steps.
The solution is to bypass this manual labor entirely with The Tutorial Maker. This is a single, advanced AI prompt that ingests a complex source document (via text, PDF upload, or grounded search) and, in one unified operation, distills it into a standardized, error-proof, step-by-step procedure. It is the automated assembly line for knowledge transfer.
This 2500-word guide will dismantle the architecture of The Tutorial Maker, showing you how to construct a single prompt that governs the persona, applies three mandatory filtering passes, and generates a structured, five-part SOP output ready for immediate use.
The Problem: Narrative Versus Instruction
Why do internal documents make terrible SOPs?
- Narrative Overload: Source documents contain historical context, justifications, stakeholder names, and future plans—all noise when the user only needs the next step.
- Implicit Dependencies: A narrative often assumes the reader knows the previous steps. The document might say, “Once the report is ready, notify finance,” but it fails to define the preceding step: “How do I generate the report?”
- Inconsistent Formatting: One document uses bullet points, another uses numbered paragraphs. A tutorial must be universally standardized for muscle memory.
The Tutorial Maker’s Goal: To impose structural clarity and actionable standardization onto unstructured text. It forces the AI to transition from the descriptive mode (which LLMs excel at) to the highly constrained prescriptive mode (which requires rigorous prompting).
The Tutorial Maker Architecture: The Three Filters
The core power of The Tutorial Maker lies in instructing the AI to perform three distinct passes—or filters—over the source document before generating the final output. These filters progressively refine the content from dense text into clear steps.
Filter 1: The Persona & Context Constraint (Scope Definition)
The AI needs to know who it is writing for and why this tutorial exists. This sets the Vocabulary and Technical Depth.
Filter 2: The Actionable Verb Filter (The Isolation)
This is the most critical pass. The AI searches for specific keywords that denote an action, isolating them from the surrounding narrative fluff.
Filter 3: The Dependency and Prerequisite Constraint (The Sequencing)
The AI analyzes the isolated actions and maps their required sequence, ensuring every step has its necessary predecessor.
Phase 1: The Persona & Context Constraint (Filter 1)
This phase is conducted via the System Instruction or Metadata Block and must define three variables: Target User, Objective, and Toolset.
1. Target User & Vocabulary
The AI must adjust its tone and jargon based on the audience. Writing for an entry-level Sales Associate is different from writing for a Senior DevOps Engineer.
Prompt Directive: “Your target user is a [Target Role, e.g., Mid-Level Data Analyst] who has a foundational understanding of SQL and internal systems but is not familiar with the [Tool Name, e.g., Azure Data Factory]. Use the tone of a friendly, highly concise subject-matter expert. Do not define common terms like ‘commit’ or ‘pull request’ but define all proprietary terms from the source document.”
2. Objective and Success Criteria
The AI must know when the tutorial ends.
Prompt Directive: “The sole objective of this tutorial is to achieve the state: [Objective, e.g., Successful deployment of the weekly financial reconciliation report to the S3 bucket]. If a step is identified that does not directly contribute to this outcome, it must be filtered out as ‘Noise.’”
3. Toolset and Environment
The AI must constrain itself to the tools mentioned in the source document, preventing it from inventing steps in external, irrelevant systems.
Prompt Directive: “All steps must be executable within the defined environment: [Environment, e.g., only Slack, Salesforce, and the internal Wiki]. Do not introduce external tools or platforms.”
Phase 2: The Actionable Verb Filter (Filter 2)
This is the isolation pass. The AI scans the source text looking for verbs that indicate a user interaction. The surrounding text—the narrative—is discarded.
1. The Mandatory Verb List
You instruct the AI to build its step-by-step guide only from sentences containing the following verbs (or their synonyms). Everything else is context or filler.
| Category | Mandatory Verbs (Synonyms) |
| Data Entry | Enter, Input, Type, Paste |
| Navigation | Click, Maps, Select, Open, Access, Hover |
| Execution | Run, Execute, Submit, Deploy, Commit |
| Verification | Verify, Confirm, Check, Review, Wait for |
| Communication | Notify, Message, Email, Approve |
Prompt Directive: “Process the entire source document. Extract and isolate only those sentences that contain a verb from the Mandatory Verb List. Treat the surrounding text as supporting detail, but do not include it as a step. For example, turn ‘The system handles data ingestion, and then you must run the data cleaning script’ into the isolated action: Run the data cleaning script.”
2. The Location Marker
To make the tutorial clear, every step needs a location. The AI must isolate the noun that is the target of the verb.
Prompt Directive: “Every isolated step must contain a specific location marker. For the action ‘Click,’ identify the specific button or link. For the action ‘Enter,’ identify the specific field name.”
| Source Text | Isolated Action + Location |
| “…and you must click the bright green ‘Submit for Review’ button at the bottom…” | 1. Click the ‘Submit for Review’ button. |
| “…then input the project number into the ‘Reference ID’ field.” | 2. Enter the project number into the ‘Reference ID’ field. |
Phase 3: The Dependency and Prerequisite Constraint (Filter 3)
This is the sequencing pass, where the AI ensures the steps are in the correct, executable order.
1. Forward/Backward Dependency Check
The AI must check if Step N requires the output of Step N-1. If Step 5 says, “Upload the generated report,” the AI must confirm that an earlier step (Step 3 or 4) contained the instruction: “Generate the report.”
Prompt Directive: “After isolation (Filter 2), perform a sequence check. If an action uses a noun that must be created in a previous step (e.g., ‘the generated file,’ ‘the approval confirmation’), ensure the generating action precedes it. If a generating step is missing from the source material, create a placeholder step: [MISSING STEP: How to generate the required asset?]”
2. The Prerequisite Header
The tutorial cannot begin until the user has all necessary components. The AI must scan the initial paragraphs of the source document for required items and extract them into a dedicated Prerequisite Section.
Prompt Directive: “Scan the first 500 words of the source document for all required account credentials, permissions, and files (e.g., ‘API key,’ ‘Admin access,’ ‘Latest Budget Spreadsheet’). List these items in the ‘Prerequisite Checklist’ section before the steps begin.”
Phase 4: The Five-Part Standardized Output
After the three filters have been applied, the AI generates the final SOP in a standardized Markdown format, ensuring universal clarity and readability.
Section A: Prerequisite Checklist
This is the mandatory inventory required before the user can begin Step 1.
AI Mandate: Generate a checklist of all required permissions, credentials, and assets. This section must be titled ‘Prerequisite Checklist.’
- [ ] Admin credentials for Salesforce.
- [ ] Q4-Budget-Forecast.xlsx (Latest version).
- [ ] Access granted to the ‘Finance Reporting’ Slack channel.
Section B: The Purpose Statement
A 1-2 sentence summary of the Why.
AI Mandate: Provide a concise, high-level summary of the tutorial’s objective and the business problem it solves.
Purpose: This procedure ensures that the weekly reconciliation data is secured and archived according to compliance standards, eliminating manual data entry errors.
Section C: The Step-by-Step Procedure (The CORE)
This is the filtered, sequenced output. It must be numbered and use only the isolated Actionable Verbs and Location Markers.
AI Mandate: Generate the step-by-step procedure using numbered lists. Each step must use a strong verb and a clear location marker (Filter 2). Use bold text to highlight all actionable nouns (buttons, fields, links).
- Navigate to the ‘Data Operations’ dashboard in Azure.
- Select the ‘Financial Reconciliation’ tab.
- Click the ‘Generate Weekly Report’ button (blue button in the top right).
- Wait for the system notification: “Report generation complete.”
- Review the generated Weekly_Rec.pdf to confirm the date range (Steps 1-5 from Filters 2 and 3).
Section D: Verification and Troubleshooting
The user needs to know how to confirm success and what to do if they fail.
AI Mandate: Extract a 1-2 sentence success criteria from the source document. Generate three potential common errors and provide a single, corrective action for each.
| Verification | Confirm that the final PDF appears in the S3 bucket and the filename is prefixed with today’s date. |
| Error 1: ‘Access Denied’ | Action: Re-verify your Salesforce Admin credentials. If the issue persists, contact the DevOps team. |
Section E: The Context and Next Steps (Optional Read)
This is where the discarded narrative context goes. It is explicitly separated so the user knows they can skip it.
AI Mandate: Summarize the historical context or next departmental action (e.g., “The finance team will now use this report to finalize quarterly taxes.”) from the source document. Title this ‘Context (Optional).’
Implementing The Tutorial Maker Prompt
The complete prompt is an amalgamation of the four phases, executed sequentially by the AI.
**[SYSTEM INSTRUCTION: TUTORIAL MAKER 4.0]**
**1. PERSONA & CONTEXT CONSTRAINT (Filter 1):**
– **Target User:** Mid-Level Data Analyst (SQL familiarity assumed).
– **Objective:** Successful deployment of the weekly financial reconciliation report to the S3 bucket.
– **Environment:** Only use steps involving Slack, Salesforce, and Azure Data Factory.
**2. ACTIONABLE VERB FILTER (Filter 2):**
– **Isolation Mandate:** Process the entire source document. Extract and isolate only those sentences containing the following verbs: `Enter`, `Input`, `Type`, `Paste`, `Click`, `Maps`, `Select`, `Open`, `Access`, `Hover`, `Run`, `Execute`, `Submit`, `Deploy`, `Commit`, `Verify`, `Confirm`, `Check`, `Review`, `Wait for`, `Notify`, `Message`, `Email`, `Approve`.
– **Location Marker:** Every isolated step must identify the specific noun (button, field, link) being acted upon.
**3. DEPENDENCY & PREREQUISITE CONSTRAINT (Filter 3):**
– **Sequencing:** Perform a forward/backward sequence check on all isolated steps. Ensure all actions are in logical, chronological order. If a prerequisite step is missing, insert a placeholder: [MISSING STEP: SOURCE DOES NOT DEFINE HOW TO GENERATE X].
– **Prerequisite Extraction:** Scan the first 500 words for required credentials or files and list them.
**4. OUTPUT GENERATION (Phase 4):**
– **Format:** Generate five distinct, labeled sections in the following order using Markdown:
– **A. Prerequisite Checklist:** (Checklist format)
– **B. Purpose Statement:** (1-2 sentence summary)
– **C. Step-by-Step Procedure:** (Numbered list, bolding all actionable nouns)
– **D. Verification and Troubleshooting:** (Table format with three errors/actions)
– **E. Context (Optional):** (Summary of narrative details)
**[SOURCE DOCUMENT INPUT START]**
[PASTE THE ENTIRE WIKI ARTICLE, TECHNICAL SPEC, OR RAW TEXT HERE]
**[SOURCE DOCUMENT INPUT END]**
Conclusion: SOPs as Code
The Tutorial Maker architecture treats documentation like code. The source document is the chaotic, verbose source file, and the prompt is the compiler that refines it into clean, executable instructions.
By meticulously defining the AI’s persona, enforcing a rigid set of filtering rules, and mandating a standardized output format, you eliminate the massive friction caused by manual documentation. You are no longer asking the AI to summarize; you are asking it to refactor knowledge. This level of structured prompting ensures that any user—regardless of technical skill—can move directly from an internal document link to a proven, step-by-step SOP in one single, reliable pass. This is the future of internal knowledge management.
