I care about coding as a craft. I am not even that good at it, but I love the tough problems, the ones that eat a whole evening before they finally crack. For a long time the idea of handing that to an agent felt like giving away the one part of the job I actually enjoy. But it is not as black and white as some quotes make you believe. The quote that kept nagging at me is from Boris, who runs Claude Code. He said coding is "largely solved". Coding very well may be largely solved, but the accountability never fades. Someone still has to maintain all this. Someone still has to understand it.
So this is not a convert selling you the faith. This is the skeptic explaining what changed his mind, reluctantly, and how I have made this work for me. What changed it was not a demo or a hot take on a timeline. It was my own pull request history showing gradually more and more hand offs to AI.
The blog post is part of the Dark Software Factory series I am writing about. My somewhat ambitious view of the future of the craft of creating software. You can read the overview of the dark software factory here. The TLDR is that I envision that we can plot the learnings of car manufacturing going "dark" onto the software delivery lifecycle, and I mean the whole thing. From idea creation to coding to operating the software. A software factory where the humans moved up and out, the lights off on the floor, agents doing the work, a named human still on the one station that stays lit to ensure someone still is accountable for this orchestra of agents.
Coding is "largely solved", apparently
Easy to wave off. That is the guy whose whole job is coding agents, of course he thinks the thing he sells is finished. I do not consider myself in the same position, but quite a bunch of people would disagree. I work for Microsoft in this space anyways. As such, I wanted to ground my bias in data. How do I code nowdays? What's the trend over the last 4 months?
Here is what I found instead.
Two lines over four months, 246 pull requests across 14 of my repos. The one I expected to be the story is the merge rate, the share of PRs that are opened (either by agents or me) which actually ship. It was already high in March, 71%, and by April and May it was basically pinned, 96 then 98. I was already merging almost everything I opened. So "will I accept the agent's code" was never really the frontier. That question had quietly answered itself months ago.
The line that actually moved is the other one. The share of pull requests a coding agent opened on its own, from an issue I assigned it and then walked away from. Flat at zero all spring. Then 28% in June.
That is the notch turning, and I can point at the exact month. The question was never "will I accept its code". It was "will I let it open the pull request at all". For a long time the answer was no, because opening the PR was mine, it was the part where I decided the work was worth showing. In June I finally stopped doing that by hand for a chunk of the work, and the world did not end.
It also explains why the merge rate went down a bit. Adopting this expanded scope for the agents obviously caused me some headaches. I am convinced that my merge rate will increase once I did sufficient harnass engineering on my repositories and coding agents.
I am not going to airbrush the cost, because the same chart shows it. June's merge rate dipped, 98 down to 86. Handing more of the work over meant more of it needed a second look before it shipped. The skeptic in me clocks that immediately. But 86% is still high, the volume went up and ultimately: it is about features delivered to users, not about who enjoyed writing the code.
This was not a switch flipping. It was a dial turning, one notch, and for once I could see exactly which notch and when. That dial is what the rest of this post is about.
We already have this framework, it is just pointed at cars
Here is the good news. We do not need to invent a way to talk about this, because the car people already did it, and they did it well.
There is no such thing as a self-driving car. There are levels of it. The car industry even wrote it down: SAE J3016 is the standard that defines six levels of driving automation, L0 to L5, and everyone sort of knows the shape of it even if they cannot recite the numbering. L2 is your car holding a lane on the motorway while you keep your hands hovering. L4 is a robotaxi that drives itself inside a mapped city but will not leave it. L5 is the thing that does not exist, the car that drives anywhere a human could, with nobody watching. Nobody jumps to L5. You earn each level, and each one is a different answer to the same question: where does the human's attention go.
You might think, what about Tesla's Full Self-Driving? Is that not L5? It sure looks the part, steering itself through town while the person in the seat sits on their hands. But it is not L5, it is not even close. SAE and the regulators file it as Level 2, driver support, and Tesla eventually renamed the thing Full Self-Driving (Supervised). The word they bolted on is the honest one. You are still the driver of record. If it runs a red light that is your ticket and your name on it, and there is a live federal investigation about exactly that gap between what the badge says and what the car actually is.
That gap is the whole reason this analogy holds for code. We watch an agent open its own pull requests and our gut says fully autonomous, the same way the sticker says full self-driving. The name runs ahead of the accountability, every time. Someone is still the driver of record. In the car it is whoever is sitting there whether they like it or not. For us it is the programmer whose name is on the merge.
The whole series runs on a factory-and-automation analogy anyway, so I am going to borrow the dial openly. It maps cleanly onto coding, and it keeps us honest. The interesting question is never "is it autonomous". It is "which notch are you actually at, and what does it take to earn the next one".
The axis that separates the levels is the same one from the car: where your attention sits. Low down, you are in the code. High up, you are out of the per-change loop entirely, watching the machine that makes the changes rather than the changes.
The five levels, on a Tuesday
Let's keep things concrete. I would like to describe how a day looks like when you operate at each level.
L1, AI in the loop, you drive. Autocomplete. You write the function signature and a comment, it fills the body, you tab through it. After a while, you may use agent mode in your editor. You hand it a small task and watch it work inline, correcting as it goes. You are still using only the the editor. This is where most people started, and a lot of very good engineers are happily parked here.
L2, delegated generation. You hand it an issue or a work item and it produces the code on its own, then you review the output. This is the first time you leave the editor and meet the work as a finished thing rather than something you watched being typed. It feels different, like reviewing a pull request from a colleague you have never met. This is also where you start to parallelize.
L3, it generates and reviews. The pull request is your only touch point. The agent has already written it, run the tests, read its own diff, and iterated before you ever saw it. Your job collapses from "the code" to "the PR". You judge whether the work is sufficient and you merge it. My June chart lives right around here, the agent opening PRs that I then judge.
L4, you leave the per-PR loop. You stop reviewing every change. Instead you watch where things go wrong and you fix the machine, not the code.
The solution to this is yet another buzz word: harnass engineering. At L4 you are not editing code, you are editing the thing that produces code: the prompts, the skills, the agents, the guardrails, the evals, the pipeline. When something ships that should not have, your fix is not a patch, it is a tighter check so that class of mistake cannot ship again. You maintain the factory, not the product. It is also worth mentioning that we should combine deterministic and non-deterministic checks.
Code coverage is worth calling out. I am going to shout out Adam Tornhill and his book. He recently was at an event I was as well, and he mentioned that before he would suggest code coverage of 80%, more or less. Now, with agents, introducing the deterministic check of 100% code coverage ensures that the agents do not "delete the tests to make them pass".
The nuance I want to hammer is that because "you stop reviewing every change" sounds like a cliff you leap off in one terrifying step. It is not. L4 is a transition you cross one class of change at a time, and if you are honest, you are already partway across without ever calling it L4.
The obvious example is dependency bumps. Dependabot or Renovate opens a PR, the tests go green, and you merge it without reading the diff. You have done this for years. Nobody thinks of it as "trusting the agent", but it is exactly the L4 move, made early, on the class of change where the checks are airtight and the blast radius is small and known. You crossed into L4 for that category a long time ago and did not notice.
So the honest framing is that L4 arrives category by category, not all at once. Dependency bumps first. Then formatting and lint fixes. Then small, well-fenced refactors where the tests really do pin the behaviour. Feature code late, if ever. You will happily let a boring change ship unread while you still read every line of anything that touches the money path. That gradient is not indecision, it is the point. It is what makes L4 feel earned instead of reckless.
L5, full trust, nobody looks. Nobody inspects anything. I am putting it on the dial because it defines the direction, but I do not believe it to be achievable right now. Not yet. It is the horizon, not a place I am telling you to go and stand.
If L3, L4 and L5 start to blur, hold onto the attention axis and they separate again. L3, you look at every PR. L4, you look at the exceptions and the harness. L5, you look at nothing. That is the whole progression.
I will be honest about where things actually are. Most serious teams live somewhere in L1 to L3 today. L4 is the frontier, and even there it is arriving one boring category at a time, exactly as described. Anyone selling you L5 is selling you a car that does not exist yet.
But someone has to maintain this
Someone has to maintain all of this. Turn the dial up and you generate more code, faster, than anyone can hold in their head, and you risk drowning in a codebase nobody actually understands. That is the primeagen-shaped worry and it is a good one. I have felt it looking at my own June numbers. More PRs, opened by something that is not me, merging into repos I am no longer reading line by line.
There is a deeper version of it too, the one I opened with. A lot of us code for the craft, for the technical pleasure of it, not for the end result. The dial threatens that directly. It is a real loss and it deserves to be named, and sometimes, remembered.
Sprawl and drift are two names for the same fear. More generated code, faster, means more surface area to rot, more places for the system to quietly drift away from what anyone intended. As you climb the dial, the failure mode changes shape. Down low it is "the agent wrote bad code". Up high it is "the agent wrote a lot of fine code and nobody is steering the whole".
The answer ties straight back to the first post's obsession with gates and brakes. The trick is not to trust the agent more. It is to make the checks more deterministic. Pipelines have been our deterministic guardrail for years, the boring wall of tests and types and lint that either goes green or does not. That wall is what let me stop reading dependabot diffs a decade ago. So expand it. More tests, stronger types, evals for the fuzzy stuff, blast-radius limits so a bad change can only hurt so much. The dial only turns as far as your checks can catch what goes wrong. You do not climb by trusting harder, you climb by building a better net.
Deterministic checks are what let you climb safely. But there is an open question underneath it that I cannot answer honestly with a yes: can checks ever cover the genuinely creative part of the work, the 20% where there is no test for "is this the right design". Probably not. And that is exactly why L5 stays a horizon and not a destination.
What turns the dial, and where it stops
So what actually moved me up a notch? Not gut feel. The data did.
Looking back at the chart, I did not sit down one day and decide to let agents open my pull requests. What happened is I noticed my merge rate had been pinned near 100% for two straight months, on work I was barely touching before it shipped, and that made a question impossible to keep answering: why am I still the one opening the PR? Why do I not provide the specification to the agent and let it run? The numbers stopped agreeing with my gut, and the gut lost. Measuring your own output is what earns the next notch, because it is the only thing that tells you the net is holding.
It is also the thing that tells you when you have turned it too far. That June dip to 86% is not a failure, it is the same instrument reading the other direction. It is the data telling me 28% is probably near my current ceiling until the checks get tighter. Turn the dial by measuring, and you also learn where to stop by measuring. That is the same self-watching loop the first post put at the centre of the whole factory, just pointed at me instead of at production.
The first post made one promise I want to keep: accountability is the one dial you never turn all the way. Every change that ships has a name on it. Every car has a driver. L5 is the level where that stops being true, where "the agent did it" becomes an acceptable answer. So L5 stays the stated horizon and not the destination, and the dial framing is what makes that coherent rather than cowardly. You turn each phase up at its own pace, which already means you stop each one short of the point where your checks and your accountability run out. For coding, that point is somewhere inside L4, not at L5.
The lights go off, but you still sometimes switch them on
There is no autonomous coder, the same way there is no self-driving car. There are levels, and the work is earning the next one without losing the thing you cannot afford to lose. The humans did not stop being responsible for the code. They moved up to maintaining the thing that writes it.
I did not stop caring about the craft. I still take the hard problem that eats an evening when I want it, the same way you might still drive a car you love on a good road even though it can hold its own lane. What changed is that I stopped pretending my enjoyment was the point of the job. The dial turned one notch in June. And I am the same reluctant skeptic who went looking to prove the quote wrong and came back half agreeing with it.
That is the honest place to land: I am not preaching that coding has been solved, it just moved a notch.
And coding is only one station on the factory floor. Getting feedback from the other stations would improve this station significantly over time. It is the one furthest along and easiest to resonate with how it would look if AI were to take over parts of it. The same dial sits on the other two: Intent creation and operation. Intent creation, where the factory starts drafting its own backlog and the question becomes which of its ideas you approve. Operation, where the agents run the thing at 3am and the brakes matter more than the code does. Each turns at its own pace, and each stops short of that last notch for the same reason coding does: someone keeps their name on it. That is where the rest of the series goes. The lights go off across the whole floor, one station at a time, and there is still a person upstairs, accountable for the whole dark and humming thing.