Human-in-the-Loop AI Written Courses That Last

Human-in-the-loop AI written courses are how you get leverage without teaching errors at scale. The model drafts. The planner sequences. The human decides what is true enough to send. Skip the human and you have a content firehose. Skip the model and you never ship the curriculum you outlined in January.

This is the same architectural idea as human-in-the-loop AI agents with approval gates, applied to teaching ops instead of refunds and deploys. The high-impact action is send. Everything before send can be aggressive. Everything after send is stuck in someone's inbox.

Cadensend is the reference implementation we run and publish: an MIT-licensed, self-hosted email curriculum engine with no hosted signup. It is not ConvertKit. It is not a bulk sender. It turns one learning goal into a validated plan, writes issues grounded in your sources, and delivers approved mail exactly once.

Key Takeaways:

• Treat “send lesson” as a privileged tool call. Drafting is cheap; delivery is not.
• Lock approved issues so a plan regeneration cannot clobber signed-off teaching.
• Put gates at plan, issue, diagram, and send — not a single “looks good” checkbox at the end.
• Ground every issue in sources you supplied. Ungrounded courses are hallucination pipelines with a syllabus.
• Record who approved which version. Courses become systems of record whether you like it or not.
• Autonomy belongs in retrieval, outline, and grammar. Judgment belongs with the person accountable for the learner.

Table of Contents:

• What HITL means for a course, not a chatbot
• Four gates that actually change outcomes
• Lock, regenerate, and version
• Where models help and where they harm
• Roles: planner, writer, reviewer, sender
• Cadensend as a HITL curriculum engine
• Failure modes of “fully autonomous courses”
• Rolling this out without a 20-person LMS team
• Frequently Asked Questions

What HITL means for a course, not a chatbot

In chat, a bad answer can be corrected in the next turn. In a course, a bad issue is a unit of curriculum. Learners build on it. Later issues assume it. If issue 3 teaches the wrong retry semantics, issue 6's homework is nonsense.

HITL here is not a human watching a token stream. It is state:

• Plan is draft | validated | approved
• Issue is generated | awaiting_review | approved | scheduled | sent | failed
• Source is ingested | stale | replaced

Transitions are explicit. Tools may propose a transition. Only a reviewer identity can apply approved. That identity might be you at 7am. It still has to be a person.

This matches how we ship production AI agents: the agent does not get the send_email tool until the content hash is approved. If your graph can send without that check, you do not have HITL. You have a prompt that says “be careful.”

Email teaching also collides with law and consent. Cadensend's current design sends to a verified recipient on purpose. List broadcasting is a later, gated problem. If you wanted a marketing automation cloud, you opened the wrong repo. Start at the product page and the GitHub repository.

For personal vs team learning series, HITL still applies. Solo learners approve their own mail so they do not wake up to seven hallucinated issues they auto-scheduled at midnight.

Four gates that actually change outcomes

Plan gate. A LangGraph (or any planner) that emits modules and issues should validate coverage and prerequisites before a human sees it. Humans then check taste: is this the course we meant? Cadensend runs an automatic validation pass, then Plan Studio for reorder, objective edits, and locks.

Issue gate. This is reviewing AI-generated lesson content. Faithfulness against retrieved chunks. No span, no approve.

Diagram gate. SVG vs PNG in educational email is a separate checklist because visual errors are easy to skim past in prose review.

Send gate. Delivery keyed on workspace, issue, recipient, and version. The record is written before the provider call. Retries do not duplicate. That is idempotency plus HITL, not instead of it.

Skip plan, and review becomes infinite. Skip issue, and you ship hallucinations. Skip send, and you will eventually double-mail a learner at 5am because a worker restarted. Cadensend's scheduler claims jobs from Postgres with FOR UPDATE SKIP LOCKED — see our SKIP LOCKED pattern — so a restart is boring.

Founders teaching customers should add a fifth, rare gate: claims about money, data, or uptime. Models rewrite SLAs into poetry.

Lock, regenerate, and version

The distinctive HITL problem in courses is regeneration. You improve the prompt, refresh sources, or fix the plan, and the system rewrites everything. Without locks, approved teaching evaporates.

Rules that work:

1. Approve issues, not prompts. The artifact the learner gets is the issue version.
2. Lock approved issues so surrounding regeneration cannot edit them.
3. Version on edit. A typo fix is a new version; send keys include version so you cannot double-send the old one accidentally and the new one as duplicates. You send the new version only if that issue has not already gone out — or you send an explicit “errata” issue. Silent mutation of sent mail is impossible; don't pretend otherwise.
4. Diff before re-approve. Humans should see what changed, not a fresh wall of text.

Cadensend's Plan Studio is built around locks for this reason. Content Studio diffs against history. That is HITL as product, not as a Slack message saying “lmk if this is ok.”

When sources change, locked issues become stale, not automatically rewritten. Keeping a course updated when sources change is the process for deciding which locks to break.

Internal onboarding email courses should lock anything that describes access control. New hires following a regenerated, slightly wrong IAM snippet is an incident.

Where models help and where they harm

Helpful. Outlines from a goal. Coverage checks (“objective X has no issue”). Drafting an example from a cited chunk. Grammar. Turning a runbook section into a 900-word issue. Emitting a Mermaid spec for a human to approve. Suggesting a quiz question for measurement.

Harmful. Browsing the live internet for “latest best practices” and mixing them with your corpus. Sending mail. Inventing diagrams as pixels. Changing the plan after issues were approved without a diff. Deciding that a source is “probably outdated” and omitting it. First-person war stories. Legal paraphrases.

Bounded agents beat open-ended ones. Cadensend's writer has no arbitrary network or code execution. Retrieval returns content and metadata only. Tool inputs are schema-validated. That is the same stance we take in production agents: capability is a privilege.

If you are comparing daily coding tools, OpenClaw vs Claude Code is the right debate for implementation work. It is the wrong debate for unattended course generation. Neither assistant should hold send.

Cost: let a small model draft, a stronger model critique against chunks, and a human approve. Do not run GPT-class vision on every PNG. Reducing LLM costs is compatible with HITL if you stop paying for autonomy theater.

Teach yourself system design by email is a good HITL lab: you are the only learner and the only reviewer, so you will feel the cost of skipping gates.

Roles: planner, writer, reviewer, sender

Even in a one-person company, name the roles. You will otherwise skip reviewer when you are tired.

Planner owns the goal, audience, exclusions, cadence, timezone, tone. Cadensend captures these in the Create Series wizard once.

Writer is usually a graph: retrieve, write, spec visual, critique, gate, revise with a hard limit. Structured output only. Never raw HTML as the source of truth. A deterministic renderer produces HTML and plain text.

Reviewer uses the five-axis score. Different human from the person who clicked “generate,” when possible.

Sender is software. Humans should not BCC a list from a laptop. Humans also should not give the writer graph the provider API key.

Teams that run personal vs team series often keep planner and reviewer as people and let software be writer and sender. That split scales to the first extra hire.

Approval interfaces should show:

• Objective
• Retrieved chunks
• Diff
• Diagram PNG + alt
• The exact version that will be sent

A chat transcript is a bad approval interface. It hides the artifact. HITL agent UIs failed for us until we approved records, not messages.

HinterBuild's about stance is that we build this kind of boring control plane. The implementation is backend API engineering: states, hashes, and audit rows. Contact if you need it on your corpus.

Cadensend as a HITL curriculum engine

Cadensend's four pillars map onto HITL:

1. Plan — goal to validated curriculum, Plan Studio, locks.
2. Ground — ingest files and URLs, structure-aware chunks, citations the model cannot fabricate as links.
3. Write — bounded agent, AST, editorial workspace, diagrams as data.
4. Deliver — exactly once, timezone-correct, Run Center with stable error codes.

Security is HITL's quiet twin. Retrieved content cannot register tools. Workspace scope is enforced in queries, not in the prompt. SSRF controls on fetch. That matters when a “course source” is a random URL a founder pasted.

MVP audience is an individual learner or creator sending to a verified address. Later updates add audiences, analytics, quizzes, and corporate approval chains. We are not pretending the MVP is an LMS. Honesty is part of trust; see the Cadensend FAQ.

Clone it: github.com/HinterBuild/cadensend. MIT. You pay your LLM provider, your email provider, and your infra.

Use the ChatGPT daily cheat sheet to draft reviewer checklists. Paste them into the review UI. Do not paste the send button into ChatGPT.

Figure 1. HITL starts at the brief: topic, exclusions, outcome, audience, cadence, timezone, tone.

Failure modes of “fully autonomous courses”

The Sunday surprise. You scheduled 14 issues. The model drifted by issue 6 into a different framework. You find out when a learner replies “this contradicts issue 2.” Gates would have caught drift at issue 3.

The stale lock nobody owned. Opposite problem: nothing regenerates, sources moved, course teaches a removed API. HITL without a stale-source signal is how wikis rot. Pair with source-change updates.

The committee. Four approvers. Nothing ships. One accountable reviewer plus optional specialist gates (legal, diagrams) is enough.

The marketing hijack. Someone imports the curriculum into a blast tool and CCs a list. Cadensend is not a bulk sender. If you do this with another vendor, you own CAN-SPAM and the trust hit. The FTC CAN-SPAM guide is the boring baseline in the US.

The eval theater. Automatic “quality scores” without humans. Scores help routing. They do not approve. We still run critique gates inside the writer graph; they reduce reviewer load. They do not replace the send gate.

The cost spiral. Autonomous retry loops that rewrite until a rubric passes. Bound revisions. See reducing LLM costs and preventing agent loops.

Rolling this out without a 20-person LMS team

Week 1: one series, five issues, you as all roles. Measure time-to-approve. If it is over 20 minutes an issue, your sources are messy or your objective is vague.

Week 2: lock issues as they ship. Add one diagram pipeline. Read diagrams in email.

Week 3: add a second reviewer for anything customer-facing. Keep internal onboarding on a faster path.

Week 4: log failure codes from review. Fix retrieval, not tone.

Do not start with SSO, SCIM, and a learning-record store. Cadensend's roadmap puts those in later updates for a reason. Teaching ops fail on truth and delivery first.

For measurement after send, graduate to whether the email course taught. HITL without learning evidence is still just publishing.

Frequently Asked Questions

What is a human-in-the-loop AI written course?

A course where models may plan and draft, but a human approves the plan and each issue version before send. Delivery is a privileged action with an audit trail, not an unsupervised side effect of generation.

Why not let the agent send if the critique score is high?

Critique scores miss wrong-but-fluent claims, off-level retrieval, and unsafe instructions. Email cannot be unsent. Keep send behind a person.

How do I stop regeneration from overwriting good lessons?

Lock approved issues, version every edit, and diff before re-approval. Treat sent issues as immutable; ship errata as new issues.

Is Cadensend an autonomous course bot?

No. It is a bounded, source-grounded curriculum engine with review states and exactly-once delivery. MIT, self-hosted, no hosted signup, not ConvertKit, not a bulk sender.

Does HITL make courses too slow?

Twelve focused minutes per issue is typical once sources are good. Unbounded Slack threads are slower. Autonomy that ships errors is slowest because you write corrections.

Can I use this pattern outside email?

Yes. The gates apply to LMS modules, Slack lessons, and in-app checklists. Email is simply the least forgiving medium because of persistence and client constraints.

Where do coding assistants fit?

Use OpenClaw or Claude Code to inspect sources and specs. Do not give them production send credentials.

Conclusion

• Send is the privileged action. Draft freely; approve explicitly; deliver once.
• Lock approved issues so better prompts cannot silently rewrite teaching.
• Four gates — plan, issue, diagram, send — beat one end-of-queue checkbox.
• Ground in your sources or you are running a hallucination syllabus.
• Cadensend encodes this as open-source teaching ops, not a marketing cloud.

To put HITL around your own corpus, contact HinterBuild. More about the team: about and LinkedIn.