A1.03 · Why an Agile Agent Workflow
The Author/Operator loop
A workflow is a shape you repeat. This one is a loop between two roles: the Operator (human) sharpens, demos, reviews, and accepts; the Author (Claude agent) specs, builds, and ships. They meet on the spec, and feedback edits it each turn.
A1.01 named the unit a rung should be; A1.02 named the principles that keep it ownable; this module is the motion — the cycle that produces one accepted rung and then the next. Three dives: who the two roles are and the line between them, how one turn runs through six owned stages, and how the loop adapts by editing the spec.
Two roles, one cycle
One rung runs as a loop. The Operator — the human, the source of intent, judgement, and acceptance — sharpens the next rung, then later demos what returned, reviews it, and gives feedback. The Author — the Claude agent, the source of production — turns the sharpened rung into a spec, builds the increment from that spec, and ships it. The Operator never writes the code; 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. When the increment is reviewed, feedback edits that spec — the dashed adapt return — and the loop runs again on the next rung. Six stages, two roles, one meeting point.
The loop · six stages, coloured by role
A repeatable cycle between a deciding role and a producing role, meeting on a shared spec, with feedback editing that spec each turn.
Each rung — one branded id, then one stored event — runs the same loop: the Operator sharpens
and accepts, the Author specs and builds Portal.ID to the contract.
The loop is the workflow's motion: two roles, six owned stages, one spec they meet on — repeated rung after rung.
The three dives
Each dive takes one part of the motion, in the arc who → how it turns → how it adapts: the two roles and the line between them, one rung's turn through the six stages, and the return that edits the spec. Read them in order — A1.03.1 starts.
The two roles
Who owns what: the Operator decides the goal and acceptance; the Author produces the spec and the code. Neither crosses the line — and why the split multiplies.
One turn of the loop
A single rung through the six owned stages, the handoffs between the roles, and the named failure that returns when a stage is skipped.
Adapt: feedback edits the spec
The return arc: feedback edits the spec, not the code, so the single source of truth stays intact and the loop compounds rung over rung.
After A1.03, the next module — A1.04 · Two layers: roadmap and specs — separates how delivery is planned from how each rung is built and proven. Return to the A1 module navigation to continue.
References
The iterative-loop tradition this motion draws on, and where it is sketched in the course.
Sources
- Beck, K. — Extreme Programming Explained — the planning/feedback loop and small, frequent releases.
- Schwaber & Sutherland — The Scrum Guide — the iterative cycle: increment, review, retrospective, adapt.
- Anthropic — Building effective agents — the human-in-the-loop pattern: human direction, agent production.