A five-stage pipeline — Plan · Implement · Trigger · Execute · Review — that converts in-loop coding (engineer prompts, watches, responds) into out-loop operation where the system detects work and fires adw_plan_build.py without a human in the conversation.

Pattern

PITER Framework

The five stages

P — I — T — E — R.

P

Plan

"what are we building?"

/product-spec

TDD + task graph

I

Implement

"did we make it real?"

ADW scripts

builder + validator

T

Trigger

"detect eligible work"

poll / webhook

claim before spawn

E

Execute

"run unattended"

detached proc

async, out-of-loop

R

Review

"is it what we asked?"

human / judge

gate before ship

Trigger detects → Execute fires ADW → Plan + Implement run → Review closes the loop Each stage is a question with an answer on disk. Vague completion is the ambient failure.

Name the five stages so you can point at the gap. A framework you can't diagnose is mysticism.

The inversion

In-loop — engineer waits. Out-loop — engineer is AFK.

In-loopPresence = 100%

Humancreates issue

Humanruns adw_plan.py

Waitwatches terminal…

Humanruns adw_build.py

Waitwatches terminal…

Humanreviews PR

Throughput ceiling = attention. Parallelization is impossible. Every step requires the human to be in the conversation.

Out-loop (PITER)Presence = 1 gate

Humanadds "ready" label

SystemTrigger detects (20s poll)

Systemclaims + spawns detached

Systemruns Plan + Implement

Systemopens PR with progress

Humanreviews PR (async)

Trigger → Review is autonomous. The engineer's presence collapses to two edge touchpoints — initiation and the final gate.

Out-loop is not faster in-loop. It's a different shape — the system, not the human, crosses the stages.

The anti-pattern

Good Plan, good Implement, no Trigger.

Most common PITER failure

The agentic layer exists. The out-loop mechanism doesn't. A human still starts every pipeline — so throughput stays pinned to attention.

PLAN

→

IMPL

→

TRIG

→

EXEC

→

REV

Result: a "good harness" that still needs a human hand on every pipeline start. The machine can build — but it can't notice that it should.

The Trigger is what separates a harness from an autonomous system. Build it.

The autonomy ladder

Presence drops from every-step → two touches → one.

Zero-Touch Engineering is the asymptote. Climb, don't leap.

Level 0

In-loop

Human present for every agent turn. Maximum oversight, minimum scale.

presence = every step

→

Level 1

Out-loop

Human initiates, pipeline runs to PR. Human reviews the Review. AFK mode.

2 touchpoints

→

Level 2

ZTE

Trigger initiates, automated Review gates merge. Agents ship. Engineer reviews at will.

1 touchpoint

Do not skip stages. ZTE without proven out-loop reliability is not automation — it's unattended regression.

Each rung is earned by the prior rung proving reliable without human rescue.

Why this compounds

One Trigger fires N pipelines. Presence doesn't scale with N.

Each Execute runs in a detached process in an isolated worktree. The Trigger loop keeps polling — it doesn't block on any one pipeline.

⚡

adw_trigger_cron.py

polls every 20s

→

→

→

→

#142feat: auth refactorrunning

#151fix: race in queuerunning

#158test: coverage gaprunning

#163chore: bump depsrunning

#171docs: API schemarunning

n pipelines = n × engineer_time

n pipelines = 1 × trigger_setup_time

The compounding leverage of out-loop operation — build the Trigger once, amortize across every future task.

The discipline

Name the five stages so you can point at which one is broken.

A pipeline that needs a human to start it is not out-loop. A pipeline that needs a human to review every output is not ZTE. PITER is the frame that tells you which stage is the gap — and throughput is whichever stage still requires your presence.