A5.7.1 · dive 1/3
The pairing
A Claude agent is a fast, tireless implementer of well-specified thin slices; the human is the source of decomposition, judgement, and acceptance. Speed from the agent, direction from the human.
The thesis the whole course argues, stated as a pairing. It is a division of labour, not a hand-off: across A1–A5 the human (the Operator) owns five layers — vision, decomposition, the spec, the brief, and acceptance — and the agent (the Author) owns one: implementation. Each is necessary; neither is sufficient. Toggle the figure to see which layer the agent owns — and which the human keeps.
The six course layers · select a layer to see its owner
A division of labour, not a hand-off
The pairing is the thesis the whole course has been arguing, stated plainly. A Claude agent is a fast, tireless implementer of well-specified thin slices. The human is the source of decomposition, judgement, and acceptance. Speed comes from the agent; direction comes from the human; the value is the product of the two. Each is necessary, neither is sufficient.
It is a division of labour, not a hand-off. Across A1–A5 the human owns five layers — vision, decomposition, the spec, the brief, and acceptance — and the agent owns one: implementation. A pairing that lets the agent take a layer it does not own is not faster. It is a fast step in a direction the Operator never set. The agent supplies speed; the workflow supplies direction; the value is what they make together.
The agent
A fast, tireless implementer of a well-specified slice. It owns one layer — implementation — and supplies speed, not direction. On its own it improvises the rest.
The human
The source of decomposition, judgement, and acceptance. The human owns the other five layers and supplies direction. On its own it builds nothing fast. The two compound.
This pairing ties back to A1's thesis and A1.05 — correct by definition. The next dive, Where the value is real, shows that on a well-specified slice the agent's speed is a clean multiplier.
Ownership across the loop
The layer split is static — it holds across the whole course. The loop is where the split plays out over one rung. The Author/Operator loop from A1.03 runs five steps: decompose, brief, build, review, accept. Four of the five are the human's. The agent owns exactly one — the build — and judgement returns to the human immediately on either side of it.
Step through the loop below. Each step lights its owner. Notice that the agent owns one step in the middle, and the steps that bracket it — the brief that sets the build up and the review that checks it — are both the human's. The loop hands the agent one step and takes judgement straight back.
The Author/Operator loop over one rung · step through the five steps
The pairing is static across the layers and dynamic across the loop — the agent owns one layer and one step, and judgement returns to the human on either side of the build.
On the Portal
The F6 ship prompts run this pairing on the Portal. They split the work across named stages under a Director — the human in the loop. Venus reconciles the spec against the as-built surface and writes the brief: decomposition and direction. Mars builds to that brief and hardens it: implementation, the one layer the agent owns. Apollo verifies the built tree against the spec: an independent check, not the builder judging itself. The Director ratifies the reconcile, confirms the liveness gate, and accepts: judgement.
The F6.6 prompt is explicit that the discipline lives elsewhere and the spawn carries only the rung delta:
“the ‘how the agent works’ fact has one authority (the agent definition), and the
prompt carries only the delta”, and “the Director coordinates and ratifies; peers
write the code.” On F6.7 the pairing reads off the prompt directly: the human reconciles
(decides whether the one new write surface update_course/2 is in scope and
ratifies it), the human briefs, the agent builds (Mars writes the broadcast helper, the
connected?/1 subscribe seam, and the Presence tracker), an independent agent
verifies, and the human accepts. Five of those six moves are the human's; one — the build — is
the agent's.
# F6.7 ship prompt — the pairing, stage by stage (the human owns five, the agent one) # Stage 1 venus reconcile + brief # human's decomposition + direction Stage 2 mars build to the brief # the agent — implementation Stage 3 mars harden the tree # the agent — still implementation Stage 4 apollo verify against the spec # an independent check, not the builder Stage 5 director ratify + accept # human's judgement + acceptance # # The liveness gate is the human's acceptance, run on a booted Portal — not the agent's self-report: # "mix test alone does NOT satisfy the liveness criterion — the endpoint runs server: false under test."
The liveness gate is where the human's acceptance lands. The F6.7 prompt is explicit:
“mix test alone does NOT satisfy the liveness criterion — the
endpoint runs server: false under test.” The Director confirms the node
boots and curl :4000/health is 200 before the one commit
— acceptance run on a real Portal, not read off a report. The request lifecycle the agent assembles
is taught in the companion course at /elixir/phoenix/lifecycle;
this course owns who decides what gets built, not how Phoenix routes a request.
The principle
The pairing is speed from the agent and direction from the human; each is necessary, neither sufficient. The human owns decomposition, judgement, and acceptance; the agent implements.
On the Portal
The F6 ship prompts split the work — the human reconciles, briefs, and accepts; the agent builds; an independent agent verifies. The Director coordinates and ratifies; the peers write the code.
Pragmatic programming with an agent is a pairing — the human directs, the agent implements, and the loop keeps judgement with the human.
Recap — speed from the agent, direction from the human
The pairing is a division of labour, not a hand-off. The human owns five layers — vision, decomposition, the spec, the brief, and acceptance — and the agent owns one: implementation. Across the loop the agent owns one step, the build, and judgement returns to the human on either side. The F6 ship prompts run exactly that split on the Portal: Venus and the Director hold direction and acceptance, Mars builds, Apollo verifies independently. The next dive looks at where this pairing pays off — the well-specified slice on which the agent's speed is a clean multiplier.
Next in A5.7: Where the value is real — on a well-specified slice the agent's speed converts directly to progress; the smaller and more specified the slice, the cleaner the multiplier.
References
Primary sources for the pairing of two roles that compound, for an agent as a fast implementer of a well-structured task, and where the loop and the companion request lifecycle this dive grounds on are defined.
Sources
- Hunt, A. & Thomas, D. — The Pragmatic Programmer — pragmatic programming as a discipline of dividing the decisions from the implementation.
- Anthropic — Building effective agents — the agent is a fast implementer of a well-structured task; the human supplies the structure.
- Beck, K. — Extreme Programming Explained — pairing as a practice: two roles working one task, neither sufficient alone.
Related in this course
- A5.7 · Pragmatic Programming with Claude Agents — the module hub: where the value is real and where it is not.
- A1.03 · The Author/Operator loop — the five-step loop this dive grounds its second figure on.
- A5 · The agent brief — the chapter landing.
- Companion · Phoenix (F6) — the real chapter whose ship prompts run this pairing on the Portal.