How much can you delegate to agents?

TL;DR Highlight

Two questions, easy to check and cheap to undo, set an agent's autonomy among four levels.

Who Should Read

A developer who decides by gut feeling how much to delegate to coding agents and lacks a clear rule.

Core Mechanics

The task decides, not the model
- Trusting agents because models got smarter is like skipping your seatbelt because you got a nicer car.
- Delegation should be set by the nature of the task.
Two questions set the ceiling
- First, is the agent's work easy to check.
- Second, is its mistake cheap to undo.
Together they give four levels
- Level 0 is hard to check and hard to undo, so the agent is an assistant.
- Level 1 is hard to check and easy to undo, so a human stays in the loop.
- Level 2 is easy to check and hard to undo, the default for most dev work today.
- Level 3 is easy to check and easy to undo, like dependency bumps, lint fixes and adding tests to existing code.
Level 0: break it down and hand off pieces
- The feature flag engine migration was hard to grep-check and had a large blast radius.
- The core migration was done by hand while SDK propagation in JS, PHP, Ruby and Flutter went to agents.

Community Reactions

Opposite of my experience, one commenter says
- Claude Code refactors feature flags better than they could and misses fewer special cases.
- What the agent struggles with is business knowledge.
Intent also needs verification, one commenter argues
- Static analysis and tests can't detect drift from the original vision.
- Reviewing only the final state hides how a conclusion was reached.
One commenter uses agents as a blind audit
- The agent proposes its own changes from the requirements, then compares them with what was done.
- They run it with spare tokens at the end of the week and haven't evaluated the payoff.
Others questioned the boundaries and basis
- One asked how to separate Level 1 human review from Level 2 safety gate.
- Another said the post seems made up rather than based on real experience and data.

How to Apply

Classify one current task into the four levels
- Ask whether it's easy to check and cheap to undo, and write down the level.
- If it's hard to check, split it and find the pieces safe to delegate.
Encode guardrails for Level 2 tasks
- Make dry-run the default in your pipeline.
- Scope credentials and put changes behind feature flags.
Give Level 1 tasks a measurable goal
- Set a numeric success criterion for subjective work before handing it to the agent.
- Turn your team's review rules into a custom skill.

Try It

copy & run

# Paste into Claude or ChatGPT as is (the article's four levels turned into a prompt)

I'm about to delegate the task below to an agent.
Task: {{task description}}

Answer these two questions and assign a level.
1. Is the result easy to verify automatically, e.g. with tests?
2. Is a mistake cheap to undo?

Levels:
- Level 0: hard to check, hard to undo (agent as assistant)
- Level 1: hard to check, easy to undo (human in the loop)
- Level 2: easy to check, hard to undo (delegate, with a final safety gate)
- Level 3: easy to check, easy to undo (self-driving)

Output: the level, two lines of reasoning, and if the task can be split, the pieces with each level.

Next step: if it's Level 2, ask for guardrail proposals such as dry-run, scoped credentials and feature flags.

Terminology

blast radiusHow far the damage spreads when something goes wrong, like the damage radius of an explosion.

LLM-as-judgeHaving an LLM grade another output, like swapping a human judge for an AI judge.

shadow modeRunning a new system on real traffic without using its results, only comparing them. It's a dress rehearsal.

dry-runExecution that prints what it would do without changing anything.

feature flagA switch that separates deploying code from turning a feature on, so you can undo by turning it off.