jonnifyagile agents

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

A1–A5: the human owns five layers, the agent one vision the human decomposition the human spec the human brief the human implementation the agent acceptance the human layers the human owns: 5 of 6
implementation — owner: the agent (Author). This is the one layer of the six the human does not own: the human owns vision, decomposition, the spec, the brief, and acceptance (5 of 6); the agent implements. Speed from the agent, direction from the human.

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

one rung: the human owns four steps, the agent one decompose human brief human build agent review human accept human steps the human owns: 4 of 5 the agent owns one step in the middle; judgement returns on either side
Step 3 of 5 — build — owner: the agent (Author). This is the only step of the five the human does not own: decompose, brief, review, and accept stay with the human (4 of 5). The loop hands the agent one step and takes judgement straight back.

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

Related in this course