Skip to specification
harnessarch

The ADLC Loop

One continuous loop: a developer expresses intent; agents implement, test, and document inline; a human reviews and approves; agents deploy, monitor, remediate, and feed what they learned back into memory. Weeks become hours.

The agentic development lifecycle — ADLC — replaces the phase-gate relay race with one continuous loop. A developer expresses intent; agents carry it through implementation, testing, documentation, deployment, and monitoring; humans stand at two stations where judgment matters; and what the loop learns feeds the next turn.

express intenthumanplan + implementagentstest + docs inlineagentshuman reviewapprove / redirectdeploy + shipagentsmonitor + remediateagentslearn + iteratememory updatedone continuous loopweeks-to-months → hourstwo amber stops — everywhere else, agents hand off to agents with no waiting
The ADLC loop. Two amber stops are human; everywhere else, agents hand off to agents with no waiting.

Around the loop once

  1. Express intent — the developer states what to build: a feature, a fix, an outcome. This is the prompt, but at lifecycle scale.
  2. Plan + implement — agents translate intent into a plan and then into code.
  3. Test + docs, inline — tests run as part of implementation, and documentation is generated alongside the change — not reconstructed afterward from memory.
  4. Human review — the developer reviews the plan and the diff, approves, redirects, or asks for fixes. The loop does not proceed without a yes.
  5. Deploy + ship — after approval, agents handle the release.
  6. Monitor + remediate — agents watch production continuously. Something breaks at 2 a.m.? Roll back to the last stable version first, report to the humans in the morning.
  7. Learn + iterate — the run's outcomes update memory: what broke, what worked, what the next plan should know.

Then around again. Cycle time collapses from weeks-or-months to hours — not because any single step got magically faster, but because the loop stopped waiting. In a traditional lifecycle, most elapsed time is handoff: work sitting in a queue for the next human. Agent-to-agent handoff has no queue.

In the wild

The key differences, side by side: sequential handoffs become fluid agent flow; humans-write-code becomes agents-write, humans-review; docs-as-afterthought becomes docs generated inline at every phase; manual midnight incident response becomes agent-assisted remediation — self-healing rollback before anyone wakes up.

The loop is the easy part

Drawing the loop takes a whiteboard. Running it raises a harder question — one every team hits the moment agents can plan, code, test, and deploy: what, exactly, do the humans still own?