I spend a lot of time pairing with coding assistants, Codex and Claude Code, on product building, machine learning, and data analysis, and if you have spent any real time inside these tools, you probably feel it too: equal parts amazed and unnerved by the pace. It is not only that the models are getting smarter, but that the harness around them, the scaffolding that lets a model plan, call tools, and keep going on its own, is improving just as fast. The distance between one month and the next feels less like steady progress and more like a series of jumps. Tasks I had to babysit at the start of the year now run for hours unattended, across long, complex, continuous work, and more often than not they land it. And the models and workflows seem to be learning about the user as they go, improving themselves as part of getting more intelligent and reliable.
Take the /insight command in Claude Code. Once a week it creates a report on how I have actually been using the agent and its harness, and a skill I built with Claude reads that report and drafts new skills to smooth out whatever has been slowing me down. It runs on its own as a scheduled workflow, with guardrails so it is not rebuilding something it already solved, or something a newer model now handles on its own. The model does all of the skill creation and wiring, working through heaps of my sessions from across the week. My effort goes into reviewing each skill it creates, line by line, making sure the skills and their reference scripts do the job the way I want and make my workflows better and not just busier. While the shift to this self-learning loop was gradual, it happened much faster than I was anticipating (as a simple stat, 80% of my skills are auto-written now and have improved my workflows dramatically). This has been coming in smaller forms for a while, in loop-first commands like /ralph-loop and /goal, and this week Peter Steinberger, who created OpenClaw, made the same point: you should not be prompting coding agents anymore, you should be designing the loops that prompt them.
Anthropic published an article last week on recursive self-improvement, and it has been doing the rounds on X, so there is a high chance you have read it by now. The core premise is that AI systems are starting to design and build their own successors. The takeaway has been near-unanimous: the machines are building the machines, and progress is moving at a pace no human can control or comprehend. That reading is true, but it stops too early. When production is no longer the constraint, the work does not vanish, it relocates to deciding what is worth building and to checking that what got built is right.
The story everyone tells, and the number under it
More than eighty percent of the code Anthropic merged into production this year was written by Claude rather than by a person. Their engineers ship roughly eight times more code per quarter than they did a few years ago. A model that handled four-minute tasks two years ago now runs on its own for twelve hours, and the benchmarks that measure software engineering went from single digits to nearly maxed out in about two years. These are their own internal numbers, self-reported by a company whose valuation rides on them being impressive and hence read them with that in mind. Even discounted, they all point in one direction, and the pace is picking up.
What is driving it? Anthropic answer almost in passing, in one line that is easy to miss: “most progress is incremental: we scale something up, see what breaks, fix it, and try again.” That grind, trying a thousand variations and keeping the ones that work, is exactly what current models are good at. Put it in Edison’s terms: genius is one percent inspiration and ninety-nine percent perspiration. The perspiration is the middle of the work, everything between knowing what to try and knowing whether it worked, and that middle is collapsing toward free.
Anthropic measure who makes the better call when a model and a human disagree on the next research step, the call the loop leans on most. In November 2025 the model beat the human choice 51 percent of the time. By April 2026 it was 64 percent. Judgment, the part people assume stays human, is already mostly the machine’s on that call, and the gap is still widening.
What a loop cannot do from the inside
“Deciding what is worth building” sounds like one skill. The word we use for it, taste, could mean three different things, and the models are taking those three over at completely different rates, so the optimism depends on which one you mean.
- One is preference, what you want.
- Another one is prediction, a guess about what will work or land.
- The third is discernment, telling the better option from the worse among a set of plausible choices.
Prediction and discernment are precisely what machine learning is, so that 64 percent is the machine doing discernment, and doing it well, picking the strongest next step toward a target. But the target is one a human set, inside a frame a human drew. Change the target and the score means nothing.
That discernment is real, and all of it happens inside the frame. The machine takes the options in front of it and picks the strongest against the target, and it does that better every month. Two things sit outside that work, one at each end, and the machine does neither: it does not draw the frame, and it does not stand behind what comes out of it. Drawing the frame is choosing the problem, the front of the work. Standing behind the result is judging whether it was any good, the back. Both are acts of authorship, and both put a person on the hook in a way the machine never is.
Anthropic name the human side of it themselves: “An area of human comparative advantage, for now, is research taste and judgment, including choosing which problems matter, which results to trust, and when an approach is a dead end.” Choosing which problems matter is the front; which results to trust is the back. They read it as a capability gap that time will close. But a loop that improves itself also sets the measure it is then graded against. Let it grade itself that way and it is marking its own homework, and you know how that ends: it gets very good at the test and the test stops meaning anything (Goodhart’s law, the moment a measure becomes a target it stops being a good measure). The standard has to come from outside the loop. So the two ends turn out to be one act seen from both sides. Choosing the problem is the outside reaching into the loop on the way in. Judging the result is the outside reaching in on the way out. I argued a version of this in Machine intelligence and its reins, that when an agent fails the instinct to swap in a different model is usually wrong, because the failure lives in the structure around the model rather than in the model itself. The loop’s purpose and its standard are part of that structure too, set from the outside. For now that outside is a person. Everything inside the frame is already moving to the machine.
Choosing the problem
The model is only ever a means to an outcome, which is the thing I find myself repeating most to the people I work with. A business has a hundred problems on any given day, and the work that matters is choosing the one worth solving, the one that moves something for the people who have to live with the result. A machine is good at part of this. It can lay the hundred out, rank them, and from what an organisation has funded and shipped and killed before, predict fairly well which one that organisation would choose, because a track record is a pile of past choices and reading it is prediction. The ceiling on that is precedent. Prediction can only re-pick the kind of problem that has been picked before, and the choices that decide the most tend to be the ones with no precedent to read, the bet nobody has made yet.
Ranking the options is also not the same as being on the hook for the one you choose. To pick a problem is to commit resources you do not get back to a bet that resolves long after the decision, and to be the one who answers for it when it was wrong. A loop has no equivalent for that exposure; it optimises toward a target without ever being the thing that suffers if the target was wrong. The deeper gap is between doable and worth doing. A machine can tell you what can be built, whether the data is clean and the metric will move, but not whether the thing is worth building, and as production gets cheap the doable problems multiply without limit. Choosing well becomes mostly subtraction, declining ninety-nine fundable and defensible problems to protect the one that counts. The hard version of the work is seeing that the problem in front of you is the wrong one; a flawless churn model is worth nothing if churn was never the question that mattered.
None of this makes the front universally more important. Where a choice is cheap to reverse, choosing well barely matters; you can run all hundred at once, keep what works, discard the rest, and a run-everything strategy beats deliberation every time. The front only binds on the bets that cannot run in parallel and cannot be taken back, the quarter that is spent once, the brand that can be spent down, the capital that does not return to be redeployed. Those stay with a person, because they are the choices that carry a downside someone has to hold.
And the more one person can aim a machine at, the stranger the shape of that becomes. When one person can point a machine at a quarter’s worth of work, choosing does not spread across a team; it concentrates, and settles on whoever carries the consequence rather than whoever does the work. The thinking was that cheap production would spread out the power over what gets made. On the bets that actually bind, it seems to do the opposite.
Judging the work, which is not the comfort it sounds like
The back is saying whether what got built is any good, and the easy human-versus-machine line breaks here, because good is two different things. Some of it is objective. Did the offer beat the baseline, did the page load, did the model pass the eval. That is grading against a standard that already exists, and the machine does it as well as it does anything, at a scale no person can match. Hand it the standard and the checking is its work to do. But the standard itself is the other kind of good, and a standard is something a person declares. When I look at a piece of writing or an image the agent made and call it good, there is no measurement under the call. I can run an A/B test, but the test only tells me which version more people clicked this week. Whether the thing is good is a different question. The test cannot see what shows up later, or the people who were never in it, or what this does to the brand three campaigns from now, and it turns hardest against anything new, because new work has no audience yet and loses to the familiar every time. Good is a claim you make before the numbers agree with you, and making that claim, then being wrong in front of everyone when it does not land, is the part that stays with a person.
Time works against this end too. The loop can rewrite itself a thousand times an hour, but whether any given rewrite was an improvement is often a question only the world answers, and the world answers slowly. Correctness is quick to confirm. Whether the thing was worth building shows up only over months of contact with reality, and the things most worth building are often the slowest to prove, because no existing measure captures them.
Take a marketing campaign of a familiar kind: a company pushes a set of offers to specific customers based on how they have behaved before, and lets a multi-armed bandit handle the allocation, shifting toward whichever offer is pulling ahead. The model can build and run the whole thing. But whether the offer cleared the bar, whether the uplift was big enough to call it a win, none of that is knowable in the moment. It comes only after real customers have seen the offers, chosen among them, and acted, which takes weeks or months. So when the loop can run a thousand iterations in the time the world takes to grade one, the thing in short supply stops being the iterating and becomes the grading, and the grading comes from a channel the world answers through: live customers, a deployed product, a feedback path that closes in weeks. A faster model buys more attempts. A shorter path between shipping something and watching real people respond buys more verdicts, which only the world can hand back.
It is tempting to stop here and treat judging as the safe high ground, the human job the machine cannot take. I do not believe it.
We might reach for Amdahl’s law, an old piece of 1960s computing math that says if you speed up ninety-five percent of a job and cannot touch the other five, the five you could not touch becomes almost the entire cost. True, and it sounds like good news for the human holding the five percent. The catch is that Amdahl assumes the part you cannot accelerate stays a fixed size. The part humans hold here grows instead, scaling with how much the machine produces.
The current trajectory is more in line with the Jevons paradox, the old observation that making coal cheaper to burn did not reduce coal use, it caused the industrial expansion that burned vastly more. Cheap production does the same to judgment. Every artefact the machine produces is one more thing someone has to check, trust, integrate, and decide is worth keeping at all. If production is becoming exponential and the judging stays human, the judging does not settle into that five percent according to Amdahl’s law. It floods, and Anthropic put a number on it: “100-person companies could do the work of 10,000- or 100,000-person organizations.” But there are still only a hundred people, and now they are the ones who have to judge everything those agents produce. Verification looks like safe high ground, but it is the next thing to get flooded, the next thing every dollar of tooling investment will aim at automating, the same way that investment aimed at production, and production fell. You can watch the dollars arrive. A whole category of eval companies, Braintrust, LangSmith, Arize, has grown up to automate the grading of model output, much of it with models scoring other models, and in March OpenAI bought one of them outright, the eval-and-red-team tool Promptfoo.
But all of that automates only one half of the good, the objective half, the part with a number under it that the machine already grades. That half floods. The subjective half has no number underneath, the call a person has to declare, and it was never an activity inside the loop, so it was never in the flood’s path. That is the half that survives, because every eval anyone builds still has to be pointed at somebody’s idea of better, and choosing that idea of better is the one judgment a loop cannot make for itself.
And when a hundred people do what a hundred thousand used to, the shape of a team changes in a specific way. You get a barbell, a thin top of people whose taste and verdict gate everything, a wide bottom of near-free machine production, and the middle scooped out, the competent producers who used to be most of the org. You only learn to verify by spending years producing. Discernment about what good looks like is earned by making bad things and watching them fail, over and over, in the middle of the work. Remove the middle and the apprenticeship goes with it, and an organisation that does that is spending down something it has no way to make more of. This falls hardest on the people coming up now. Anyone who learned the craft over years, before the machine could do the middle, already has the taste and the instincts those years built. The generation starting today is asked to judge work it never had to make, with the rungs that used to lead up to that judgment already pulled away. The gap between the people who earned their taste the slow way and the people who will not get the chance to is the real problem here, and it is the one we will have to solve. The ai-native orgs reach this first. Built to maximise output, output is the number they watch, and the cost that matters here, that no one underneath them is being trained to judge the work, shows up on no dashboard until the people who could have done that training are already gone.
If the scarce thing floods and the pipeline that produces it is being removed, then “have good taste” is thin advice. Individual taste is hireable, mobile, and on the same path to automation as everything else. The obvious next move is to capture it, to write down every correction until the record itself encodes what good means here, a thing the machine can run without you. That helps, and it is also a trap if you stop there, because a written-down standard is fixed and the world it was fit to keeps moving. Goodhart comes back one level up: the recorded definition of good becomes a target, and a target stops tracking the thing it stood for the moment the ground shifts under it, a new channel, a customer who behaves differently, a better thing the old standard marks down. A recorded standard does not tell you when it has gone wrong; it just keeps passing things that should no longer pass. The written-down version ages while the world moves on, so the part that actually holds is not the record but the habit of noticing it has drifted and writing it again, which is the one thing a record cannot do for itself.
The loop I run, and the gate that is mine
The skill-writing loop I opened with is the small version of all of this, and it is turning up in a lot of other areas too, in projects like Nous Research’s Hermes agent that build their own skills and keep pushing toward running unattended (agent-workflow-patterns is mostly about that, structure that catches the model when it is wrong). The models do more on their own every month, and need me to step in less and less. But the work still runs through one gate it cannot skip, and that gate is me. A loop cannot certify its own output, and that judgment has to come from outside it.
A couple of Anthropic’s own researchers describe the darker reading of this, the feeling on some days that the work no longer needs them. The feeling is real, I do too. But it’s hard to sieve out which part left. The machine took the middle, and the choosing and the standing behind the result were always the exposed parts, where you commit and then answer for it. Those parts stay with me and I want to keep it that way, at least for now.
The people I worry about are the ones coming up behind us. You learn to tell good from plausible by making the plausible version yourself, over and over, and watching it fail. That practice lived in the middle, the part the machine now does. Taste is earned that way. It is the kind of judgment I argued was the skill that actually compounds once the machine can do the rest. So you keep building it by doing the middle on purpose: make the bad version yourself sometimes, even when the machine is faster, and protect some of that slow work as training. On any output number that work looks like waste, so the companies that run on output cut it first, but the cost lands later. You reach for someone who can tell good work from plausible work, and no one was trained to. This is the part I think we should be afraid of, more than the models getting smarter. If you are early in this, it is also the part that is still yours to refuse.
The want and the verdict are mine for now, the way the producing was mine three years ago and is not anymore. The loop runs most of the week without me, then stops at the one thing it cannot do: say this is the problem, and later, this is good. Someone has to, and for now that someone is me. How long that role stays mine matters less than whether anyone behind me is still being built to take it.