Readiness for autonomous development is not a tool choice. It is whether a process has owners, rules and checks an autonomous agent can work inside. Take one process, for example code review, dependency updates, incident triage or test maintenance, and work through it step by step. An hour with the process owner is enough for a first pass.
1. Pick the process
- It has one named owner who can change how it works.
- It runs often enough to measure, weekly or more.
- You can show real recent examples, including the ones that went wrong.
- You know roughly what it costs today: hours, waiting time or incidents.
2. Five questions for every step
| Question | If the answer is no |
|---|---|
| Is the input to this step available in a system, not only in someone’s head? | The step stays with people until it is written down. |
| Is “done” for this step defined so that someone else could check it? | Write the acceptance rule first. It helps your people today too. |
| Can the result be checked by a test, a second reviewer or a measure, rather than by trust? | Keep a person on the decision. |
| Is a mistake in this step cheap to detect and undo? | Keep a person on the decision, or add the check first. |
| Does the step need access you would not give a new hire in their first month? | Narrow the access before anything is delegated. |
3. Sort each step into one of four stages
- Stays with people: judgement, accountability or relationships you choose to keep.
- Existing software or an assistant: automation or a coding assistant already does it, or could, with a person still deciding.
- An agent under clear rules: all five answers are yes. The agent acts, and a check or a person reviews the result. No agent approves its own work.
- Candidate for an agent-run team: several connected steps in stage 3, with one owner who sets the rules and reads the results.
Steps move between stages over time. Most processes end up mixed, and that is the expected outcome, not a failure.
4. Before the first step is delegated
- A person is named who decides what the agent may do, and who stops it.
- The acceptance rule is written and checked automatically where possible.
- You have a baseline: how the step performs today, so you can compare.
- The agent’s access is limited to what the step needs, and its actions are logged.
- You know when a person steps in: the exceptions and thresholds are written.
What you have at the end
A map of one process by stage, the first step worth delegating, and the prerequisites in its way. Most of that work makes the process clearer even if you decide not to delegate yet.
We run our own development this way at agent.ceo, an autonomous development system built by our group. See how it fixes its own bugs.