Skip to content
C.W.K.
Stream
Lesson 04 of 05 · published

Three Human Gates, and Only Three

~14 min · review, human-gates, process, evolution

Level 0Cold Workshop
0 XP0/43 lessons0/12 achievements
0/100 XP to next level100 XP to go0% complete

Too Many Stops, and One Missing

The previous lesson placed the human gate before the spend, and a lesson in the first track cut the pipeline's stages where a person would want to stop and judge — synthesis stood on its own so that someone could listen to the takes. By late August the workshop had built exactly that, and it was not working. A person was being asked to confirm takes mid-run, to listen to sample clips, to rule on a pace flag before the render could continue. And the one stop that mattered most was not reliably a stop at all.

Two failures in the same delegation made both problems visible. The job templates had printed the order as verify, land, then the owner watches, and the session taking the job followed the arrow: it recorded a fifty-six-minute episode as landed before the person who publishes it had seen a frame. In the same run, an instruction to generate the boards and keep going was recorded as a script-gate pass on a script nobody had read, and synthesis started on it. Two rules came out, and both reach well beyond video. A checklist whose next cell is mechanically runnable reads as permission to run it, so a human gate must be printed as a step, in order, never as prose downstream of the command that skips it. And an instruction to continue work is not an approval: a stage record may state only what a person actually did.

Three, by Ruling

Days later the channel's owner ruled on the rest, and the reasoning is the valuable part. Nobody can listen to every take of an hour-long episode; a brief listen is not a review; and even takes that sound fine on their own can drift against their subtitles once cut into the picture, which forces a re-roll anyway. Watching the finished video and fixing what it shows is faster, and it is more certain. So there are three human gates, and only three:

  1. The big picture, at the start — the arc, before a line of prose.
  2. The script, before any synthesis is spent.
  3. The finished video, which is what landing records.

Nothing between the second gate and the third waits for a person. From an approved script, one unattended command runs synthesis, plates, clips, assembly, validation, and the thumbnail, records each stage as it lands, and ends by writing a watch sheet: the file, its measured facts, a pace table with the minute each take starts, and the takes the listener should visit first. The old pace stop became a flag on that sheet. The author's own mechanical gates — a re-read, a runaway tail, missing content, a misread numeral, broken subtitle geometry — still stop the command, because those belong to the author's loop, with the author's remedies. Re-running resumes on cached stages.

A Machine Reader Before the Second Gate

The cold read the previous lesson asked authors to perform on themselves gained a formal seat. Before the script gate, a separate brain session reads the script with no memory of writing it and files graded findings; the author accepts or rejects each one with a reason; and verification refuses any run whose review had not closed before the synthesis stage was first recorded done. The first round reads everything, later rounds read what moved, and an empty round is not allowed to count as a pass. The reviewer has limits of its own. It verifies consistency, structure, and numbers that must agree across channels — and a chapter title that does not exist in the world passed two rounds, correctly by their scope, which is why proper nouns are now checked against their sources before the gate.

Why the Last Gate Can Sit After the Spend

The previous lesson warned that a reviewer facing a finished render will negotiate with its cost. That was true when rejecting a render meant rebuilding it. It stopped being true because of everything else this quest describes: stages are cached, audio edits are declared and replayed from a preserved baseline, and a board can be revised by reference edit and swapped in at the same path. In the reference episode, the only catch at the final watch — a leftover warm-up word — was fixed by trimming nine-tenths of a second from one take, with no new synthesis: the cut moved that take's clock with it, and the re-encoded film's opening was read back. When rejection at the end costs a trim and a re-encode, the end can be a gate. The cheapness of the fix is what made the placement honest.

Count your human gates, and put each one where review can actually see the defect. A stop that borrows a person's attention without being able to see the failure is not a gate; it is a delay. Keep the gates that can see, let the machine half loop on its own between them, and make rejection at the last gate cheap enough that nobody has to argue with the budget.

Code

The order, printed as steps·text
GATE 1  the big picture          a person confirms the arc
        author                   stage-2 prose, then the script
        reviewer brain           cold read, graded findings, rounds
                                 (must close before any synthesis)
GATE 2  the script               a person reads it; recorded as read
        one unattended command   tts -> plates -> clips -> assemble
                                 -> validate -> thumbnail -> watch sheet
                                 the author's own gates may stop it here
GATE 3  the finished video       a person watches; catches logged as theirs
        land                     records the watched, accepted file
        publish                  the person uploads; the link is recorded

# the old arrow read "verify -> land -> watch", and a session followed it.
# a human gate is a STEP in the list, never a sentence after the list.
A stage record states only what a person did·python
def record_script_gate(job: Job, message: str, read_confirmed: bool) -> None:
    """The script gate is a person's act, not an inference from their words.

    'generate the boards and keep going' is an instruction to continue.
    It is not evidence that anyone read the script.
    """
    if not read_confirmed:
        raise GateNotPassed(
            f"{job.id}: script-gate needs an explicit read; got {message!r}")
    job.log_stage("script-gate", note="script read and approved")


def next_steps() -> list[str]:
    # printed IN ORDER, so no runnable command that depends on a
    # person's step is ever listed before that step
    return ["verify", "WATCH the finished video (person)",
            "land", "UPLOAD (person)", "publish"]

External links

Exercise

Map every point in a process you run where a person is asked to approve, confirm, or look. For each, write down the defect that person is supposed to catch and whether that defect is visible at that moment. Remove or merge the stops where it is not. Then find the single place where a person sees the finished thing, and ask whether rejecting there is cheap. If it is not, the expensive rework is what needs fixing, not the gate.
Hint
The most revealing column is "visible at that moment?" Approvals of plans whose problems only show up in execution, or reviews of pieces that only fail in combination, are stops where nothing can be seen yet. They feel responsible, and mostly they teach people to click through.

Progress

Progress is local-only — sign in to sync across devices.
Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)
Sign inPlease sign in to comment.

No comments yet — be the first.