The Author/Operator loop

The framework moves as a loop between two roles. The Operator — the human — sharpens, reviews, and accepts; the Author — the Claude agent — specifies, builds, and ships. One thin rung at a time, and feedback edits the spec. Select a role to see which stages it drives.

The two roles Where they meet References

One rung · select a role

One rung runs as a loop. The Operator (human) sharpens, demos, reviews, and gives feedback; the Author (agent) builds and ships. Feedback edits the spec, and the loop runs again.

The Author and the Operator

The loop runs between two roles. The Operator is the human: the source of intent, decomposition, and judgement. They decide what the next thin rung should be, demo and review what comes back, and accept it or send it round again. The Operator never writes the code — their scarce, valuable attention goes to deciding what matters and whether it was met.

The Author is the Claude agent: the source of production. It turns a sharpened rung into a spec, derives the stories and the agent brief, builds the increment, and ships it — fast, exact, and tireless. The Author has no taste for what matters, so it never sets the goal; given a clear spec, it does the work a person would find slow and repetitive.

Run alone, each role fails: an Operator without an Author ships nothing, and an Author without an Operator ships the wrong thing, confidently. Paired over thin, provable rungs they compound — the human's judgement at the start and end of every rung, the agent's throughput in the middle.

Operator (human): Intent, decomposition, judgement, acceptance. Sharpens the next rung; demos, reviews, and signs off. Writes no code.
Author (agent): Production. Drafts the spec, derives the stories and brief, builds, and ships — thin but robust. Decides no goals.
The pairing: Neither ships reliable software alone. Judgement at the ends of each rung; throughput in the middle.

Where the roles meet: the spec

The two roles meet on one artifact: the spec. The Operator's sharpened intent becomes a spec; the Author builds from that spec and nothing else; and when the increment is demoed and reviewed, feedback edits the spec — never the code directly. The spec is the contract, and it is the only thing both sides commit to.

That single meeting point is what keeps the handoffs clean. Sharpen hands a settled spec from Operator to Author; ship hands a running increment from Author back to Operator; and adapt routes every correction back through the spec, so the next turn of the loop starts from one agreed truth. Select a side to see what it owns.

The handoff · select a side

The Operator (human) owns intent, decomposition, and acceptance. They sharpen the next rung and judge what returns — but never write the code.

Two roles, one contract, one loop: the human decides and accepts, the agent specifies and builds, and the spec is where they meet. That is the whole engine of the workflow.

References

Primary sources for this design, and where it connects in the course.

Sources

Hunt, A. & Thomas, D. — The Pragmatic Programmer — tracer bullets and tight feedback.
Beck, K. — Extreme Programming Explained — the planning/feedback loop and small releases.
Anthropic — Building effective agents — the operator/author division and the loop between them.