The two roles

One rung runs as a loop between two roles, and the design is the line between them. The Operator is the human: the source of intent, judgement, and acceptance. The Operator sharpens the next rung, demos what returns, reviews it against the spec, and decides whether it is done. The Operator never writes the code — that scarce, valuable input is judgement, and spending it on production wastes it.

The Author is the Claude agent: the source of production. The Author turns the sharpened rung into a spec, builds the increment from that spec and the brief, and ships it — fast and exact. The Author never decides the goal. The two meet on the spec: the Operator's sharpened intent, authored into the contract the Author builds from. Neither side proceeds on anything else.

The pairing is not a convenience; it is a multiplier — but only under one condition. The Author's throughput is near-unlimited, while the Operator's judgement is the scarce input. So accepted value is produced only as fast as the Operator can accept: the Author can build ten rungs in the time the Operator has to review, but if accepting each one means re-reading every line, nine of them wait.

That makes cheap acceptance the lever. When each rung carries its own acceptance — a contract, a test (A1.02.2) — the Operator accepts many per cycle, and the Author's throughput converts to shipped value. When acceptance is expensive, the throughput is wasted. Step the slider: the same production, a different acceptance cost, a different amount that actually ships.

On the Portal — the learning platform this course builds — the Operator decides the next rung (“one branded id”, then “store one event”) and what done means: the id contract from A1.02.2. The Author turns that into a spec and implements Portal.ID.generate/1 to satisfy it, then ships. The Operator demos (the id decodes), reviews against the contract, and accepts.

The line holds throughout: the Operator never writes generate/1, and the Author never decides that an id is the right next rung. The spec — the contract — is the one place they meet.

# Operator: decides the rung and what "done" means (the contract) — never writes the code.
#   "next rung: a branded id; done = 14 chars, decodes to its type, unique within a node-ms"

# Author: turns that into a spec and produces the code to satisfy it — never decides the goal.
id = Portal.ID.generate(:user)        # => "USR0NbAb1xcFCy"

# Operator: reviews against the contract, then accepts.
assert Portal.ID.decode(id).type == :user   # meets the spec → accepted

Two roles, one line. The Operator owns intent, judgement, and acceptance and never writes the code; the Author owns production and never decides the goal; the spec is where they meet. The split multiplies only when acceptance is cheap, which is exactly what the contract bought in A1.02. With the roles fixed, the next dive walks one rung through the six stages they hand back and forth.

Primary sources for the two-role division of labour, and where it connects in the course.