Home / ADLC / 2 · Agent & Human Co-Development
ADLC · Slide 2 Co-Development Model

Agent and Human
Co‑Development

Agent Execute, Human Steer. The fundamental division of ownership that makes agentic development both fast and safe.

Agent and Human Co-Development Agent owns reversible tasks, Human owns irreversible judgement Slide 2 · ADLC Framework · Author: Prashant Dhingra
The core split

Who owns what and why it matters

The division is not arbitrary. It is grounded in a single property: reversibility.

💡
Agent Owns
Reversible · Verifiable · Executable
Code Generation
Writing implementation from spec; output is inspectable, testable, and replaceable.
Test Authoring
Creating unit, integration, and regression tests against defined acceptance criteria.
Refactoring
Restructuring code for maintainability without changing observable behaviour.
Code Documentation
Generating inline docs, READMEs, and API references from existing code.
Simple Debugging
Diagnosing and fixing well-scoped, reproducible failures with clear signals.
🔁 Reversible mistakes can be caught and corrected
vs
⚙️
Human Owns
Irreversible · Judgement-Driven · Strategic
Problem Definition
Scoping what is being built and for whom; a poorly defined problem propagates through every downstream stage.
Architecture
Structural decisions about systems, boundaries, and trade-offs that are expensive to unwind once made.
Risk Identification
Recognising what could go wrong technically, operationally, and in terms of business impact.
Risk Acceptance
Deciding which risks are tolerable, which require mitigation, and which block progress entirely.
Stage Approval
Signing off at every gate that the work meets the bar to proceed a non-delegable accountability.
🔒 Irreversible errors compound; judgement cannot be outsourced
The guiding principle

Reversibility is the axis of delegation

Every task in software development sits somewhere on a spectrum from fully reversible to fully irreversible. The ADLC uses this single property to determine the appropriate level of agent autonomy no heuristic, no exception.

← Agent territory (reversible) Shared zone Human territory (irreversible) →
Agent Write a sorting function
Human Choose a database engine
Agent Generate API documentation
Human Define service boundaries
Agent Refactor duplicate logic
Human Accept security risk trade-off
Agent Write regression test suite
Human Approve production release

"The agent is the fastest, most tireless executor in the room. The human is the only one who can be held accountable for what gets built. Co-development works when you stop asking the agent to be accountable, and stop asking the human to do what the agent does better."

Prashant Dhingra, Agentic Development Lifecycle Framework

What this means in practice

Implications for how you build

Adopting co-development isn't just a tooling change it reshapes team structure, review processes, and how progress is measured.

🗂️

Task decomposition changes

Stories and tickets must explicitly label agent-eligible vs. human-required work. Mixed tasks need to be split before sprint planning begins.

✅

Review is lighter, not gone

Agent-generated code still gets human review but the bar shifts from "did a human write this well?" to "does this correctly satisfy the verifiable criteria?"

🚦

Gate approval stays human

No matter how high the autonomy level, every stage gate requires explicit human sign-off. This is what makes high autonomy safe to operate.

📋

Accountability is always traceable

The human who approves a gate owns the outcome of that stage. Agent output is a contribution, not an excuse responsibility cannot be delegated to a model.

📐

Architecture debt is a human problem

Because agents execute within the architecture humans set, structural mistakes are amplified at scale. Getting architecture right is more important than ever.

📈

Speed increases where it's safe

Teams consistently find that delegating reversible work to agents dramatically reduces cycle time on implementation freeing humans for strategic work.