ADLC Six Stages   Intent to Deployment

Q: What are the 6 stages of the Agentic Development Lifecycle?

The 6 ADLC stages are: A) Intent & Framing, B) Specification, C) Planning, D) Execution, E) Verification, and F) Operation. Each stage runs from Intent to Deployment, with defined agent and human roles at every step.

Q: What happens at Stage A Intent & Framing in ADLC?

At Stage A, the goal and success criteria are defined. The agent drafts candidate framings; the human approves the final framing before work proceeds to specification.

Q: What is the role of the agent and human at each ADLC stage?

At each stage: A Agent drafts, Human approves. B Agent generates acceptance criteria, Human accepts. C Agent creates task sequence, Human sets guardrails. D Agent produces deliverable, Human reviews and signs off. E Agent self-tests, Human reviews and signs off. F Agent suggests releases, Human authorizes.

Prashant Dhingra

A

01 / 06

Intent & Framing

Define the goal before building anything

The first stage establishes what is being built and why not how. A poorly framed problem propagates through every downstream stage, compounding in cost and rework. The agent drafts candidate framings rapidly; the human owns the approval of the final definition, ensuring it reflects real business and user need.

Goal statement Success criteria Scope boundary Stakeholder sign-off

Agent Drafts multiple problem framings, proposes success criteria, and surfaces scope ambiguities for human review.

Human Approves the final problem framing and success criteria. This is a non-delegable judgement call the human owns the definition.

B

02 / 06

Specification

Testable acceptance criteria with constraints

Stage B translates the approved intent into precise, machine-verifiable requirements. Specifications must be testable vague requirements cannot be validated by an agent or a gate. The agent generates draft acceptance criteria from the approved framing; the human reviews for completeness, correctness, and constraint coverage before accepting.

Acceptance criteria Constraints doc Edge cases Non-functional reqs

Agent Generates testable acceptance criteria, constraint lists, and edge case inventories from the approved intent definition.

Human Accepts the specification, resolves ambiguities, and confirms that all constraints technical, legal, and business are correctly captured.

C

03 / 06

Planning

Decompose into a task graph with guardrails

Planning converts the specification into a structured execution plan a task graph with dependencies, sequencing, and effort estimates. The agent is well-suited to decomposition work; humans set the guardrails that define what the agent is and is not permitted to do autonomously during execution. Guardrails are the boundary of delegation.

Task graph Dependency map Guardrail definition Autonomy level per task

Agent Creates the task sequence, dependency graph, and effort estimates. Proposes which tasks are candidates for autonomous execution.

Human Sets guardrails the explicit boundaries of what the agent may do without human review during Stage D execution. Approves the plan.

D

04 / 06

Execution

Build, test, self-correct within guardrails

Execution is where the agent operates at its highest velocity. Within the guardrails set in Stage C, the agent builds, tests, and self-corrects iteratively producing working deliverables without waiting for human input at each micro-step. When the deliverable is complete, the human reviews the output holistically and signs off before the stage gate closes.

Working code Test results Self-correction log Human sign-off

Agent Produces the deliverable autonomously within guardrails: writes code, runs tests, detects failures, and self-corrects until criteria are met.

Human Reviews the completed deliverable against acceptance criteria and signs off at the stage gate. Escalation point if guardrails are breached.

E

05 / 06

Verification

Evidence creation prove it before it ships

Verification is a dedicated stage, not a checkbox at the end of execution. The agent runs the full test suite, generates evidence artifacts coverage reports, conformance matrices, failure logs and performs self-assessment against the acceptance criteria defined in Stage B. The human reviews the evidence, not just the code, before signing off for release readiness.

Test evidence package Coverage report Conformance matrix Release readiness verdict

Agent Self-tests against all acceptance criteria, generates evidence artifacts, and produces a structured verification summary for human review.

Human Reviews the evidence package not just the test pass/fail and signs off that the output is ready for production release. The gate is human-held.

F

06 / 06

Operation

Deploy, monitor, and feed back into the cycle

Operation is not the end of the ADLC it is the feedback loop that improves every future cycle. The agent monitors production behaviour, detects anomalies, and proposes release actions (rollback, feature flag change, patch). All release authorizations remain human-held. Operational signals feed back into Stage A of the next iteration, making the framework self-improving.

Production metrics Anomaly alerts Release proposals Feedback to Stage A

Agent Monitors production, surfaces anomalies, and suggests release actions (rollback, patch, flag toggle) with supporting evidence.

Human Authorizes all release decisions. No production change including rollback is executed without explicit human authorization.

ADLC Six Stages

From Intent to Deployment

Agent & Human roles across all 6 stages