Most engineers starting with agentic development are doing it on a legacy application: the system that pays the bills, built up over many years, where a mistake costs real money.
Two things get people stuck. The advice says what to build and never where to start. Build a harness, write skills, keep guidance files, get CI and CD in place, route the work to the cheapest model that can do it. All of it is right eventually, almost none of it pays this month, and you cannot do it all at once. And almost everyone stalls in the same place: the agent writes the code and you spend all your day performing code reviews and fixing the code. Faster typing, same throughput.
Below is the process I suggest to follow: four phases, what to do in each, what to leave for later. Each ends at a gate that either happened or did not, so you can tell where you are.
Do not try to move your whole product through a phase. Each part of your codebase sits in its own phase, and you move them one at a time. Pick the first one carefully: an area you change often, understand well, and where a mistake is easy to spot and easy to undo.
A monolith works too. Its areas are the clusters of code you keep touching together, and you already know them. The cost is that a change belongs to the lowest phase of any area it touches, and in a monolith changes cross areas more often, so the same mechanism runs slower.
Find your phase. Do what it says. Move on at the gate.
Find the sentence that sounds like you, and click its phase.
Phase 4 is not better than phase 3. These are levels of autonomy, not quality, and a team may stop on purpose where its risk model needs a human gate.
1
Hand over the typing
The idea behind this phase
You scope the work and hand over the coding. The agent does a code review, and so do you. Your markdown files improve from what you both find. You move on when the code written for you is mostly right.
You are here if you ask the agent for a function, a component or a fix, and adapt what comes back, one or two sessions at a time. You still write the hard parts yourself, because you do not trust the agent with them. So you never see it fail on those, and you never learn what it is bad at. Its runs take under a minute, so you are never waiting long enough to start a second session.
What this phase is about. You hand the coding over a bit at a time. You decide what to build, the agent builds it. Then the change gets two code reviews. The agent goes first and fixes what it finds, which clears the obvious problems, so you can spend your time on whether the change is in the right place and the design is right. Then you read the whole diff yourself. The agent's review is only an opinion: it cannot stop a merge. Nothing in this phase can except you. Phase 2 builds something that can.
What to do
What blocks you in this phase is your own typing, and then your own reviewing.
Set up first
Start with the person who experiments the most, not the one who is most enthusiastic. Enthusiasm for AI doesn't predict who gets furthest. The person who keeps trying things and takes big steps does, and that can be the biggest sceptic. Expect the rest of the team to be spread across the phases.
Set up a report of how long a change takes from first commit to merged, and how long CI takes, and watch it from the first day. A harness only gets slower, because every incident adds a check and nothing removes one: mine went from under a minute to eleven minutes in three weeks. When a number gets worse, fix it that week. (Managing your harness)
Write down what your product does and why, one document per part. Without it, the agent can only tell what the code does today, so you re-explain the product every time you scope something, or it guesses. Write what each part does for the person using it, not too high and not too low, and only for the area you are about to touch. (Scoping)
Write down your technical strategy, for the area you are about to touch. Legacy code does the same thing in two or three ways, and to an agent they all look equally valid. Write down which services exist, where data lives, where new files go, and which of two ways is the current one. (Managing your architecture)
Build a scoping skill that asks you what you would otherwise forget. Tell it everything you can think of, and let it grill you on cases and edge cases until nothing that would change the build is left open. (Scoping)
Use one linter for your coding standards and your architecture rules. Fail the build on them, including two or three boundaries you never want broken, and record today's violations so only new ones fail. It is the only thing in this phase that catches a change in the wrong place without you reading the diff. (Managing your architecture)
With every change
Hand over the coding, in code you can still judge yourself. Start where you can tell whether the result is right, and have the agent show each test failing before it writes the code. (Testing)
Do a code review of every change twice: the agent first, then you. The agent reviews and fixes on your machine, which is faster than CI and costs no pipeline time. Then you read every line.
Do not correct styling preferences. Only correct real problems. Let different names and order go. Speak up when the code is wrong, will break, or sits in the wrong place.
Put each correction where it will hold. A correction typed in a prompt is gone when the session ends. Give it the strongest place you can: a linter rule or a type, then a test, and only then a markdown file. Every few weeks, do the same for what keeps coming back. (Learning)
Let the product side start building proofs of concept. Something you can click answers a question about what to build better than a week of discussion. It is throwaway: engineering still builds the real thing.
Through when
Your code reviews stop turning up new kinds of mistake.
What you still find is the same short list every time, such as a wrong import or a missing permission check, and a check could catch each of those instead of you. Building those checks is phase 2.
Reviewing has become the bottleneck. To go faster you have to stop reviewing yourself, which needs a harness you can trust. Building that is this phase.
You are here if the agent writes most of your code and it is mostly right. You do a code review of every change before it merges, and that is where your day goes. You want to run more at once, but you are the only thing between a change and production.
What this phase is about. You build the thing that checks, instead of being it: tests, linting and the boundary rules from phase 1. The agent runs them itself, sees what it broke and fixes it before you look.
What to do
What blocks you in this phase is your own reviewing, and then how slow and expensive your harness has become.
Set up first
Write a testing skill that tells the agent which kind of test to write for what, and let the agent decide which tests a change needs. Without it, the agent writes the easiest test, which on a legacy codebase is a slow browser test. You don't define the tests yourself; you check them on the coverage page below. (Testing)
Build a page that shows which business rules are tested, not which lines ran. List the product rules you have written down, with the test that checks each one next to it. A rule with no test next to it is a gap. (Testing)
Move most of QA's time off writing and running tests. The agent does both now, but QA's judgement is worth more in this phase than in any other: choosing which tests are worth having, keeping the harness lean, and exploratory testing of what the people using it will actually do.
With every change
Write tests for the code you touch. Tests for code nobody is changing only record what it does today, bugs included.
Refactor only to make your tests faster. Moving logic out of a controller so a fast test can reach it is safe, because the test you just wrote covers that move. Anything bigger changes behaviour no test covers yet, so it waits for phase 3. (Testing)
Let the product side build proofs of concept on the real product. The tests now say whether a rough version in the real codebase broke anything. It is the first thing the harness buys anyone outside engineering.
Through when
For one area, you trust the tests more than your own reading of the diff.
Not when the suite is green or coverage hits a number. When you have stopped double-checking a kind of mistake yourself, because the harness keeps catching it first.
For one area, not for the product. You pass this gate once per area, and the first time will be in whatever you touch most.
The reviewing bottleneck is gone, so an engineer has more time to build and does more at once. Product now has to scope the right thing, faster.
You are here if your tests catch things before you do. You hand over whole changes, but you scope each one and start it yourself, two or three at a time at most. You answer the agent's questions while it works, so the change comes out fine and you never find out the ticket lacked the answer. The next ticket lacks it too.
What this phase is about. Your harness catches things before you do, so you have time to run more than one change at once. But every change still has to be defined, and you are the one defining it. Until now the scope did not have to be complete, because you were sitting there. The agent asks "should an expired coupon be deleted or only ignored?", you answer, and it carries on. That works for one change at a time. With three running you cannot answer all of them, and when the person who wants the change is a product manager, they may not know the codebase well enough to answer.
What to do
What blocks you in this phase is how fast and how well the work gets defined.
Set up first
Let anyone who can describe the outcome run the scoping skill. Waiting for someone with the codebase in their head is now the bottleneck. A product manager, a support lead or an engineer runs the same skill and gets the same shape of result. (The team)
Change your infrastructure so three or more pieces of work can run at once. Each needs its own branch, ports, data and environment, and each copy has to be light and fast enough to start. Two agents in one checkout is the first thing everyone tries and the first thing that breaks. (Running agents in parallel)
With every change
Answer the agent's questions in the ticket, not in the chat. An answer typed into the session goes away with it, and the next ticket has the same hole. Write it into the ticket and tell the agent to read it from there.
Make the skill ask what you used to fill in yourself. Every time the agent has to ask, or a feature comes back for a second round, add that question to the skill.
Write tickets in product language, not implementation. Write "customers see an error when their coupon expires during checkout", not "make CouponService.validate() return 409", so someone who doesn't track the code can write and check it. (Scoping)
Take on the bigger refactors you have been putting off. You have added tests to every area you touched since phase 2, so a much bigger refactor is now safe. (Testing)
Through when
Ordinary work goes from ticket to merged without anyone having to supply something the ticket left out.
Routinely, on ordinary work, not once by luck.
A real decision still gets asked, and should. Two conflicting product rules need a person. What has to end is the agent coming back for something the scope should have said, because in phase 4 nobody is there to answer.
Scoping, coding and reviewing can all be trusted now. What is left is to automate the whole process: hand over the loop, and run even more at once.
You are here if you write a ticket and the agent builds it without asking. You still start each change, check on it and remember to run the code review yourself. That is at least five steps on every change: scope, build, test, code review, fix what the review finds, merge. None is hard, but every one needs you. It works at two changes at once and falls apart at four, when you forget a step on the one that mattered. Your setup is also built for three tracks. Ports, databases, preview environments and CI capacity each become the constraint in turn.
What this phase is about. Scoping, coding and code review can be trusted, so the last thing you still do by hand is running those steps in order. You hand that over too, then run more at once than you could ever watch.
What to do
What blocks you in this phase is having to drive every step yourself.
Set up first
Build one /build skill that takes a ticket all the way to merged. It checks the ticket is ready, builds, tests, reviews, fixes what the review finds, and keeps going until the pull request is merged, not until the checks are green. It points at your rules instead of copying them. (Automating the build)
Build the infrastructure for six or more pieces of work at once. Six worktrees, six sets of ports, six databases, six preview environments and six pipelines at once. What you set up by hand for three will not cope; expect this to be most of the phase.
Make the product strategy hold. Engineers now get through several times more work, so product has to decide that much more, further ahead. Write down what you want to become and where you invest, so product can say "no" and "not now" fast. Development got cheaper. Being wrong did not. (Product strategy)
With every change
Watch what parallel work does to your process and your architecture. Merge conflicts pile up in the same two files, or reviews queue up behind one person: those cracks tell you what to fix next. No tool tells you the team is stuck, so you have to look. (The team)
No gate
This is as far as the map goes, because I have not run far enough past it to say what the next constraint is.
Everything here stops at merged. How a change reaches production, what an unattended agent may touch, how a bad change is noticed and how cheaply it is undone: that has to hold next. I have not run it, so it is not on this map.