Home / ADLC / 4 · RICE-A Test
ADLC · Slide 4 Task Delegation Test

RICE-A Test

Delegate to agent only if it passes all five. A structured decision test that governs every task assignment in the Agentic Development Lifecycle.

RICE-A Test Reversible, Inspectable, Constrained, Low Error Cost, Autonomy ADLC role assignment framework Slide 4 · ADLC Framework · Author: Prashant Dhingra
✅
All 5 pass → Agent can do it
Every criterion is satisfied. The task is reversible, verifiable, well-constrained, low-cost on failure, and matched to an appropriate autonomy level. Delegate with confidence.
⚠️
Any 1 fails → Human owns it
A single failing criterion means the task carries risk the agent cannot safely manage alone. The human takes ownership no exceptions, no partial delegation.
The five criteria

What each letter tests

Each criterion targets a different failure mode of over-delegating to an agent. Together they form a complete safety screen.

R
Reversible
Can it be undone cheaply if wrong?
Reversibility is the single most important safety property of agent-assigned work. If an agent makes an error on a reversible task, the fix is local and bounded. If the task is irreversible think database schema migration, public API change, or a financial transaction a mistake propagates forward and compounds. Tasks that cannot be easily undone stay with humans.
✓ Write a function ✓ Refactor a module ✗ Rename public API endpoint ✗ Delete production data
I
Inspectable
Can the output be verified by test or review?
If you cannot check whether the agent did the task correctly, you cannot safely trust the output. Inspectability requires either automated verification (tests, linters, type-checkers) or a feasible human review path. Tasks whose correctness can only be assessed by running in production with real users are not inspectable enough to be agent-owned.
✓ Generate test suite ✓ Document an API ✗ UX copy for emotional resonance ✗ Business strategy framing
C
Constrained
Do clear and testable criteria exist?
An agent without constraints is an agent without a success condition. Constrained tasks have explicit acceptance criteria that can be checked either by the agent itself or by a gate. Vague tasks ("make this better", "improve performance") cannot be reliably assessed and so cannot be safely delegated. Specification quality directly determines whether this criterion passes.
✓ Sort list ascending, all tests pass ✓ Response time < 200ms under load ✗ Make the UI feel more intuitive ✗ Improve developer experience
E
Low Error Cost
Is the cost low if things fail?
Even reversible, inspectable, constrained tasks can carry high error cost if they are on a critical path, involve sensitive data, or block many downstream teams. Error cost is not just about reverting a change it includes detection time, blast radius, customer impact, and reputational exposure. High-error-cost tasks require human oversight even when other criteria pass.
✓ Draft internal documentation ✓ Generate mock data for dev env ✗ Modify authentication logic ✗ Deploy to production on Friday
A
Autonomy
What level of autonomy applies?
The first four criteria determine whether to delegate. Autonomy determines how much. A task may pass R, I, C, and E but still require human checkpoints at each sub-step (Level 2) rather than full autonomous execution (Level 5). Autonomy level is set by the human at Stage C (Planning) based on demonstrated agent reliability at that specific task type not optimism.
L1–L2 Human-led or co-piloted L3 Supervised autonomy L4–L5 Agent-led or fully autonomous
The gate

Apply the test at every stage gate

The RICE-A test is not applied once at the start of a project. It is re-applied at each ADLC stage gate as context changes a task that passes early may fail later as its blast radius grows, or pass later as agent reliability in that area is established.

R
Can the output be reverted without costly side effects?
I
Can correctness be confirmed by test, lint, or review?
C
Are acceptance criteria explicit and machine-checkable?
E
Is the blast radius of failure bounded and tolerable?
A
Has the right autonomy level been assigned and approved?
Outcomes
🤖
Agent can do it
All 5 criteria → PASS
The task is safely within the agent's operating envelope. Assign at the determined autonomy level, set guardrails, and proceed. The human reviews the output at the stage gate not every micro-step.
👤
Human owns it
Any 1 criterion → FAIL
The task carries risk that the agent cannot safely manage alone. The human performs or oversees the work. This is not a failure of the agent it is the framework working correctly. The agent may still assist, but accountability stays human.
In practice

Worked examples

Applying the RICE-A test to common software development tasks showing how the criteria interact to determine ownership.

Task R I C E A Owner
Write unit tests for a utility function ✓ ✓ ✓ ✓ ✓ Agent
Refactor a module to reduce duplication ✓ ✓ ✓ ✓ ✓ Agent
Generate inline code documentation ✓ ✓ ✓ ✓ ✓ Agent
Choose microservice architecture boundaries ✗ ✗ ✗ ✗ ✗ Human
Modify authentication token validation logic ✓ ✓ ✓ ✗ ✗ Human
Rename a public REST API endpoint ✗ ✓ ✓ ✗ ✗ Human
Fix a failing CI pipeline step ✓ ✓ ✓ ✓ ✓ Agent
Approve production release to 100% of users ✗ ✓ ✓ ✗ ✗ Human

"The RICE-A test is not a barrier to using agents it is what makes high-autonomy operation safe. Every task an agent handles confidently was first earned by passing this test. The test is not skepticism of agents; it is respect for where errors become expensive."

Prashant Dhingra, Agentic Development Lifecycle Framework