This page is for people who want to bring coding agents into real software work and are not sure where to begin. Perhaps you have been asked to adopt GenAI, perhaps you are curious on your own account. It is the entry point to the AgenticCodingHub cluster. The other pages in the cluster explain individual techniques; this one tells you what order to do things in, why that order, and how to know when you are ready for the next step.
The goal is not that you adopt a particular set of techniques. The goal is that you can try any technique on real work, safely, and decide from your own numbers whether to keep it.
Most of this page is argument rather than instruction. The order of the stages is a claim, and you should be able to check the reasoning behind it and disagree where your situation differs.
The path works for one person on their own project and for a small team sharing a codebase. It assumes only a few things:
No particular title, team size or prior experience with agents is needed. If you have never let an agent edit a file, start at stage 0. If you have been using one for months, read the exit tests and start at the first one you cannot pass.
If you work with others, it helps for one or two people to go through the first two stages before everyone joins in. Reviewing other people's agent output is much easier once you have seen your own go wrong.
The path puts tests and CI ahead of feature work. That looks backwards to anyone who wants a quick result, so here is the reasoning, one question at a time.
Because an agent changes what is expensive. Before agents, writing a change took most of the time and checking it took less, so checking kept up without anyone designing it to. An agent makes writing cheap. It does not make checking cheap. Whatever was the slower step now sets the pace for everything.
That leaves two outcomes if checking is left as it is. Either people check every agent change properly, in which case review becomes the queue and delivery is no faster than before. Or they check less carefully to keep up, in which case more defects reach users. Neither is the result anyone wanted from adopting agents.
Three reasons, and they compound.
So review by people remains necessary, but it cannot be the only check once output goes up.
Because its check shares its mistake. If the agent misunderstood the requirement, the tests it writes afterwards encode the same misunderstanding and pass. Its report that the work is done comes from the same understanding that produced the error. A check is only worth something if it can fail independently of the thing it checks.
This is why the path asks for checks that exist before the change and that a person has verified: a test suite the agent did not write for this change, or one whose strength has been proven by breaking the code on purpose.
Because an executable check does two jobs, and the second is easy to overlook.
The first job is catching mistakes before they merge. The second is giving the agent something to steer by. An agent works in a loop: change, run, read the result, change again. With a fast, trustworthy test command, a wrong change produces a failure the agent can see and correct by itself. Without one, the agent has no signal, so it stops when the code looks finished. The same agent on the same task produces better work in a codebase with good tests, because it gets told when it is wrong.
A better prompt improves the first attempt. A better harness improves every attempt and catches what gets through. Models and prompts also change every few months; a test suite keeps its value across all of them.
You need somewhere to learn how the agent behaves in your code, and harness work is the cheapest place to learn it.
A practice project teaches less. It has none of your codebase's traps, so what you learn about the agent does not carry over.
Because tests and containment guard against different things. A test tells you, after the fact, whether a change is correct. It does nothing about what happens during the session: a credentials file read into the conversation, a directory deleted, a force push. Those are not wrong changes that a later check can reject. They are done when they are done.
The cost is also lopsided. Containment takes an afternoon. The things it prevents are rare, but some cannot be undone, and over hundreds of sessions rare things happen. AgentContainmentAndBaseline goes through each control and the reason for it.
Because people are poor judges of their own speed with these tools. In a 2025 randomised study by METR, experienced open-source developers working in their own repositories took longer on tasks when allowed AI tools, while believing they had been faster. That is one study of one group and should not be read as "agents slow you down". What it does show is that the feeling of speed and the fact of speed can point in opposite directions.
There is a second reason. If you choose what to measure after seeing how things went, you will tend to choose the measure that flatters the result. Deciding the measures first removes that option.
Each stage ends with something you can observe, not a duration or a quantity of work.
If you already pass an exit test, skip the stage. If you cannot pass it, do not move on, however well the demos went.
| Stage | What you do | Exit test | Playbook |
|---|---|---|---|
| 0 | Contain the agent and record a baseline | The agent cannot read secrets or change the main branch; four baseline numbers are written down | AgentContainmentAndBaseline |
| 1 | Build a test harness and CI gate for one slice of the code, using the agent | A bug you plant in that slice is caught by CI in minutes; the tests are shown to fail when they should | AgentBuiltTestHarness |
| 2 | Run bounded trials of techniques on that slice | One technique has been tried, measured against the baseline, and kept or dropped in writing | AgenticTechniqueTrials |
| 3 | Make what worked repeatable | Someone who was not in the trial gets a comparable result from the written instructions alone | Reference pages below |
| 4 | Run work in parallel and hand work off unattended | Unattended changes pass the same gate as attended ones, and review load has not grown | Reference pages below |
| 5 | Run the whole line as a system | Work moves from request to release through defined steps, and each step has an owner and a measure | Reference pages below |
Stages 0 to 2 have step-by-step playbooks. Stages 3 to 5 are currently covered by reference pages rather than playbooks.
Before the agent does any real work, decide what it is allowed to touch and make that decision enforceable rather than a matter of trust. Then write down a few numbers about how work gets delivered today.
Pick the part of the code you will work in next. Use the agent to bring its tests and CI to the point where a planted bug is caught quickly. The skill you are really learning here is checking the agent's tests, not writing them.
Why one slice and not the whole codebase? Two reasons. A harness only earns its keep where code is changing, and tests on code nobody touches catch nothing. And "improve our testing" has no end, while "a planted bug in this module is caught" does. Work with no finish line gets abandoned when something more urgent arrives.
With containment, a baseline and a harness, you can try things. A trial is one technique, on one slice, for a fixed period, with a written prediction and a written decision at the end. This is the stage you never leave: every later stage is entered by running a trial.
Why one technique at a time? If three things change together and the numbers move, you cannot say which one moved them, so you cannot say which to keep.
Stage 3 moves what worked out of someone's head and into the repository: standing instruction files, written task specifications, and packaged procedures.
Why does this come after trials and not before? Writing a practice down costs effort and makes it harder to change. It is worth doing for something you have shown works, and wasteful for something you are still guessing about. And why is it needed at all? An agent starts each session knowing only what is written down. Whatever made the technique work, if it lives in one person's habits, is absent from every session that person does not run. That applies on a solo project as much as on a team.
Running several agents at once, or handing off work you will not watch, takes your attention out of the loop. Until now your attention has been quietly covering gaps: noticing the agent heading the wrong way, stopping a bad command, remembering a rule that was never written down. Once you are not watching, only what is written (stage 3) and what is enforced (stages 0 and 1) is still there. That is why this stage comes after them. Parallel work also multiplies output, so it multiplies whatever weakness remains in the checking.
A software factory is a way of working in which the path from request to release is a defined line: intake, specification, build, verification, release, and learning from what escaped. Agents do most of the work at each station and people own the decisions and the line itself. It can be one person or many.
You get there by repeating stage 2 on each station in turn. Why not design the whole line at once? A redesign changes many things together, so when results change you cannot tell which part helped, and when something breaks you cannot undo one part. Station by station, each change is small enough to measure and to reverse.
Arguments should come with their limits.
AgenticCodingFailureModes catalogues the ways agent work fails, and VerificationLoopsForAgenticCoding covers the checking machinery in depth. AgenticCodingMaturityModel describes the levels of practice; this page is the route between them.