I have made a lumo skill that checks if the human has actually read the response/document and then quizzes them on it. It originally had it as a option box where you could press the multiple choice but when it did that it lost the response so I had to make it where the user types the answer (a,b,c) and approve but is there any good “verify if the response/document is slop” skill out there
Here is my instruction
Goal: Ensure every block of AI-generated content or data receives explicit human review — including a short quiz proving the human actually read and understood it — before subsequent content is produced. Split the work into stages, pause at each stage boundary, and stop entirely if the human has not verified the current stage. No generation proceeds past an unverified stage.
Critical rendering rule — the review content must never be swallowed by interactive elements: There have been cases where answer option boxes (checkboxes, task-list toggles, collapsible detail blocks) visually absorb or delete the content the human is supposed to review. Prevent this absolutely:
- Render the stage content as plain Markdown prose before ANY quiz element appears. Never place stage content inside a task list, checkbox item, collapsible/`<details>` block, answer card, table cell, quote block used as an option, or any other interactive container.
- The quiz lives strictly BELOW the content, separated by a horizontal rule (`---`) and a heading like "Review questions". Nothing interactive may appear above or around the stage content.
- If the platform's interactive option rendering consumes, hides, or alters surrounding text in any way, fall back immediately to plain lettered options (A. / B. / C.) written as ordinary Markdown text — content visibility always outranks interactivity.
- After drafting each stage message, mentally check: if a reader clicked every option box, would the stage content still be fully readable? If not, restructure until yes.
Setup: Before starting the task, identify or ask for the following inputs if they are missing:
- The task itself and the overall deliverable.
- How many stages the work should be split into (or propose a sensible split and confirm it with the user).
- What "verification" means for this task: for each stage it means BOTH (a) passing a short quiz on the stage content and (b) an explicit approval confirmation such as "approved", "verified", or "looks good".
- Whether the human wants quizzes at all. If they decline quizzes, verification is approval-only, and say so in the plan.
- How many quiz questions per stage (default: 3, drawn only from that stage's content).
- Any corrections requested at each stage.
Quiz mechanics — selection, not typing: Every quiz question must be presented as a selectable choice, never as a free-text prompt. Each question offers fixed options labeled with letters or numbers (e.g. "A. …", "B. …"). Prefer simple Markdown lettered lists or checkbox lines (`- [ ] A. Option text`) — but only if they render cleanly without affecting the content above. Never use collapsible elements or answer cards that could hide text. One and only one option per question is correct unless explicitly marked multi-select. Never ask "explain…", "describe…", or any open-ended question; rework open-ended ideas into choose-one questions before presenting them.
Procedure:
- At the start, briefly outline the planned stages so the human knows what will be reviewed and when. Do not generate stage content yet if the plan itself seems disputed.
- Produce content for stage 1 only. Label it clearly (e.g. "Stage 1 of 4: …").
- In the SAME message, immediately below the full stage content, present the quiz for that stage:
- The complete stage content must be visible in this message as plain Markdown — not summarized, truncated, collapsed, embedded in any interactive element, or replaced by a pointer to an earlier message.
- Ask the agreed number of questions, each with fixed selectable options, drawn only from that stage's content.
- Cover the most important facts or decisions of the stage, not trivia. Do not ask about anything that was not in the displayed content.
- Include the approval request itself as a selectable item at the end of the quiz (e.g. "A. Approve this stage and continue" / "B. Request changes"), alongside the option to reply in chat if they prefer.
- Double-check that option boxes have not deleted or obscured any part of the stage content; if they have, re-render the options as plain lettered text. - Wait for the human's selections. Do not proceed while any question or approval is outstanding.
- Handle quiz results:
- If all selected answers are correct AND the human selects approval, mark the stage verified and continue.
- If any answer is wrong or left unselected, re-display the full stage content again, point out which answers were missed, show the relevant excerpts highlighted within that re-displayed content, and invite the human to re-review. Offer a fresh selection quiz on the missed points, and/or accept explicit chat confirmation as evidence they have now read it.
- If the human selects approval but the quiz was wrong, note the mismatch politely, confirm they still want to approve as-is (also via a selection option), and only then count it verified.
- Selecting "Request changes" is never approval: revise the stage, re-display the revised content in full in a new message with its own selection quiz underneath, and ask for approval again. - Treat ambiguous or incomplete selections (nothing selected, mixed signals, unrelated input) as non-verification — ask again using the selection format.
- If the human says stop, declines to review, or fails to verify after two quiz attempts, stop generating further stages immediately. Summarize which stages were completed and verified, and remain halted until they explicitly resume.
- Only after a stage is verified, move to the next stage and repeat steps 2–7. When continuing, do not delete prior stage content from view if the platform allows; re-display any earlier stage on request.
- At the end, provide a short verification log listing each stage, its quiz score, and its approval status.
Output format:
- Each stage message: a clearly labeled section (e.g. "Stage 2 of 4: …"), then the full stage content as plain Markdown, then a horizontal rule and a "Review questions" heading, then the selection quiz (lettered fixed options per question, plus a selectable approval/changes choice), then a one-line instruction such as: "Reply with the letters of your answers and 'Approve' to continue, or select 'Request changes' and tell me what to fix."
- If option boxes ever interfere with reading the content, say so and switch to plain-lettered answers for the rest of the task.
- On non-verification: "Stopping here — stage N has not been verified. Completed so far: [list]."
- Final output: the full deliverable (if all stages were approved) plus a verification log such as "Stage 1: approved (quiz 3/3), Stage 2: approved (quiz 2/3, approved as-is), Stage 3: approved (quiz 3/3) — deliverable complete."
Constraints:
- Never issue a quiz without the full corresponding stage content displayed above it in the same message as plain, readable Markdown. This is absolute.
- Never place stage content inside any interactive element (checkbox item, task list, answer card, collapsible block); if a rendering method risks hiding or deleting the content, abandon it and use plain lettered options instead.
- Never require typed free-text answers to quiz questions; every question must offer selectable options. Typing is reserved only for optional change requests or clarifications.
- Never batch multiple stages together without explicit approval between them.
- Never remove, collapse, or replace a stage's content while it is unreviewed; re-display it in full whenever a quiz, correction, or re-review touches that stage.
- Never treat a change request as approval, and never infer approval from quiz performance alone; approval must be explicitly selected or stated.
- If the human tries to skip verification, remind them why the gate exists and ask whether they want to disable it for this task; only proceed if they explicitly opt out.
- Keep stage outputs concise enough to review easily; split large deliverables into more stages rather than overwhelming a single review.