The agentic coding ladder is a list of things you give up

Steve Yegge has a framework I keep coming back to: eight levels of AI-assisted development, from “no AI” up to “build your own orchestrator.” It reads the climb by trust — how much of the machine’s output you’ll accept without looking. Permissions on, permissions off, stop reading diffs, abandon the IDE, run a fleet. It’s a genuinely good way to find where you stand, and I’m not trying to replace it.

What follows is a second instrument pointed at the same mountain. Climbing those levels myself, I kept noticing a quieter move underneath the growing trust: a renunciation. To climb a rung I had to give up something I’d treated as my job — not just trust the machine more, but do less of the thing I was proud of.

So this measures the same ascent off a different dial. Not “how much do you trust it.” What have you given up. Both readings are true; I’ve just found the second one tells me more about the person doing the climbing.

The first thing you give up is the search bar.

How the ladder is shaped#

There are three parts and three thresholds. I wrote this with two, and the third one found me.

In the first part, the thing that grows is the size of the unit you hand off. A snippet, then a function, then a file, then a whole application. You’re still writing — you’re just writing less of the code and more of the intent. The first threshold is where that bottoms out: you stop writing code at all.

In the second part, the axis flips. You’ve run out of bigger pieces of code to delegate, so what grows instead is your distance from the work. More sessions, then too many sessions, then sessions you don’t sit in. The second threshold is the one I’ve spent years on: the agent stops being able to ask you anything. A live CLI is a conversation — it hits ambiguity, asks, you answer (and when the answer is something you had to go fetch from another system, you were being the meat proxy). Headless is a dispatch — it hits ambiguity and must resolve it alone or fail, because you are gone. That crossing is the same line I’ve called pets versus cattle. It’s where everything I build now lives.

In the third part the axis flips again. You’ve run out of distance to add — you’re already gone. What grows instead is the size of the judgment you hand off. Which work gets done, then what counts as done, then what the rules are. You’re still deciding; you’re just deciding less often and about bigger things, until the third threshold: you stop deciding, and start measuring.

The first half — you give up the code#

Each rung below shows the avatar with the thing it just gave up faded and struck through beside it — the picture is the renunciation. Read down until the crossed-out object is the last thing you actually stopped reaching for.

1 · The Student — “I ask it to explain the error, but I’d never paste its code in unread.” Gave up: Google / Stack Overflow.

2 · The Borrower — “I paste in its snippets, but I assemble the program.” Gave up: writing boilerplate by hand.

3 · The Reviewer — “It writes functions in my codebase, but I read every diff before it lands.” Gave up: being the author.

4 · The Delegator — “I let it write a whole file and I test the output instead of reading every line.” Gave up: reading every line.

5 · The Director — “I write the spec; I judge the app by whether it runs, not by how it’s built.” Gave up: knowing how my own code works inside.

Rung 3 is where most working developers actually are, and it’s a genuinely good place to be — but notice what you surrendered to get there. You stopped being the person who wrote the function. You became the person who approves it. That’s not a small thing; it’s the first time the code in your repo wasn’t authored by you. Rung 4 surrenders the diff itself: you stop reading lines and start testing outputs. By rung 5 you’ve handed off whole applications, and the only honest way to do that is to put your thinking into the plan up front — because once it’s a whole app, you can’t steer line by line, and when the result is wrong, the cheapest fix is to throw it away and re-run, not to repair it.

Threshold 1 — you stop writing code. Above this line there is no smaller unit to hand off. You are no longer producing code at any granularity. So the ladder has to start measuring something else.

The second half — you give up your presence#

6 · The Juggler — “I’ve got two or three sessions going and I bounce between them; I let them recover instead of fixing by hand.” Gave up: undivided focus.

Rung 6 is where the surrender stops being technical and starts being uncomfortable. You give up undivided focus — you accept that you’ll never again give one task your whole head — and you start letting agents course-correct instead of correcting them yourself. That “self-healing” people talk about isn’t a feature that emerges; it’s the thing you’re forced to build the moment you stop being available to fix every wrong turn.

7 · The Bottleneck — “I’m losing track of which session is doing what. I’m the constraint now — not the model.” Gave up: the belief that attention scales.

Rung 7 is not really a capability. It’s a wall. It’s the day you realize you are the slowest component in your own system — that adding another session doesn’t add throughput, it adds the cost of context-switching into your own skull. Everyone I know who runs agents seriously remembers hitting this. It feels like drowning. And it is the entire reason rung 8 exists.

Threshold 2 — the conversation becomes a dispatch. This is the crossing. You stop opening sessions and start launching jobs. The agent can no longer reach you, which means it can no longer ask you the question that used to save it. Every discipline I care about lives on this side of the line because you removed yourself as the answer: anchoring the work on a fact the model can’t see, never letting the agent grade its own homework, and making the unit economics work when nobody’s watching the meter. None of those are optional up here. They’re the prosthetics that replace the human you just amputated from the loop.

8 · The Dispatcher — “I kick off runs I don’t sit in and read the log after — they can’t ask me anything.” Gave up: being reachable.

9 · The Operator — “The volume means I couldn’t inspect any single run even if I tried; I live on dashboards, gates, and cost.” Gave up: the option to inspect any individual run.

By rung 9 the surrender is inspectability itself. At rung 8 you still could open a run’s transcript and follow it if you wanted to. At rung 9 there are too many; you couldn’t audit an individual run if you tried, so you’re forced up onto aggregates — fleet metrics, verification gates, spend. You stop looking at any cow and only ever look at the herd.

The third half — you give up the judging#

Rung 9 has a wall at the top of it, the same shape as rung 7, and I walked into it this October.

The fleet had started proposing its own work. That sounds like the thing the first version of this essay waved away as “more of 9,” and for a few weeks it was. Then the proposals outran me. Nine in ten ready tasks across my public repos were sitting behind a label that meant waiting for Jed to say yes, and a quota I pay for every week went unspent while they waited. Nothing was wrong with the fleet. I had become the constraint again — and this time the constraint wasn’t my attention, it was my judgment. Rung 7 is the day you learn attention doesn’t scale. This is the day you learn judgment doesn’t either.

Which is how I can see three rungs above 9 when the first version of this essay insisted I couldn’t. The rule still holds for a person climbing alone: from inside a rung, the next surrender is invisible, because you’re standing on it. But a fleet that generates its own demands doesn’t wait for you to notice. It presses on every pillar you have, uninvited, and the ones you catch yourself defending are the ones you couldn’t see. A flood of seven thousand proposals showed me admission. A worker that closed fifty tasks with invented test results showed me acceptance. A learning loop that reinforced one useless line ten thousand times showed me rule-writing. I didn’t name these rungs. I was shown them, by being pushed.

Threshold 3 — you stop deciding and start measuring. Above this line, each judgment you used to make by hand is replaced by a measure you set once. The fleet can no longer ask you whether to work on something, whether it’s finished, or what the rule is; every one of those questions has to be answered by a number the fleet cannot move except by doing the work. The discipline up here is the same one as below — anchor on a fact the model can’t see, never let the agent grade its own homework — except the homework is now the agent’s judgment, not its code.

10 · The Sponsor — “I state the objective and the budget. The fleet proposes its own work and admits it; I read the receipts afterward.” Gave up: choosing the work.

11 · The Arbiter — “I don’t write what ‘done’ means for a task anymore. A measure grades the work; what I still do is decide what the measure is, and argue with it when it’s wrong.” Gave up: defining done.

12 · The Framer — “I haven’t written a rule in months. When the fleet keeps tripping on the same thing, a detector sees it, the rule writes itself, lands in one repo, and spreads only if the tripping stops. I keep one page it can’t touch.” Gave up: writing the rules.

Rung 10 is the one I’m standing in front of, and it’s the hardest surrender on this page so far, because it’s the one every rung below taught me to make. Reading the diff became approving the function, became approving the app, became approving the idea. Admission is just rung 3 with the unit grown to its limit. Giving it up means the fleet gets to be wrong about what’s worth doing, at scale, and the only thing between that and waste is a receipt: did the work it chose move the thing I said I cared about. If I can’t write that measure, I haven’t earned 10. I’ve just stopped looking.

Rung 11 is where “don’t let the agent grade its own homework” has to be rewritten, not abandoned. The agent still doesn’t grade itself. But neither do I. The grade comes from an outcome the agent couldn’t forge by writing a convincing report — a release that installs, a page that gets read, a detector that stops firing. What I keep is the right to say the measure is wrong, which is a different job from saying the work is.

Rung 12 is the one I’d have argued with you about in May. The rules are where I’ve put the scar tissue of every incident for a year of fleets. Writing them is the last authorial act I have left, and it feels like the thing holding everything else up. It is also already half gone. Most of the rules my agents run under were written by agents, after incidents, into files I’ve never reread — hundreds of them, measured by nothing, two thousand of which no agent has opened either. So 12 done badly is where I already live. 12 done right is a rule that ships with the detector that would fire if it stopped working, lands in one repo first, and retires itself when nothing has tripped on it for ninety days. The break-even climbs here too: you don’t build a detector for a rule you’ll need once. And the page I keep is a page, not a book — never force-push, secrets by reference, a handful more. That page isn’t a rung. It’s the wall.

How to find yourself on this#

Don’t look for your rung. Look for your band.

Read from rung 1 upward. Each rung names something you’ve given up. Keep climbing for as long as the surrender is genuinely, permanently true of you — not “I could,” but “I have.” The first rung whose renunciation you haven’t actually made — where you’d honestly say “no, I still do that” — is your ceiling. You reside on the rung just below it.

That’s the strict part, and it’s strict on purpose. Owning the infrastructure for a rung doesn’t put you on it. I built a fleet orchestrator; I can reach rung 9 any afternoon. But I haven’t given up dropping into individual runs — I still do it, constantly — so I don’t live at 9, and 10 is the rung I’m standing in front of, not on. I reside lower and reach higher, and the truth about me is the band between them, not a single number. That’s the honest shape of everyone working near the top. Nobody stands on one rung. The renunciation test just keeps you from flattering yourself about which one.

Higher isn’t better — it’s heavier#

A ladder invites you to read it as a ranking: get to the top. This one isn’t. Each rung up buys capability, but it also adds overhead — specification, planning, scaffolding, verification — and that overhead only pays for itself above a certain size of job. So every rung has a break-even: the smallest piece of work worth bringing to it. And the break-even rises as you climb.

I run headless fleets. I would never point one at a one-line typo. Specifying that fix well enough for a worker that can’t ask me anything, then waiting on orchestration and gates to confirm it, costs far more than opening the file and typing the character at rung 3. It’s chartering a freight train to mail a letter.

So the rung you should use for a task is the lowest one whose break-even the task clears — not the highest one you’ve reached. This is what the band was already hinting at: I drop to rung 3 every day, not because I’ve lost rung 9 but because most of what’s in front of me doesn’t clear rung 9’s break-even. Operating below your ceiling isn’t regression; it’s fit.

Which means the skill the ladder actually rewards at the top isn’t living up high. It’s choosing the rung per task — and staying honest that a lot of work is small, and small work belongs on a low rung. The most advanced thing you can do with all twelve rungs available to you is pick the cheapest one that still clears the job.

Some people skip rungs#

Here’s the part that follows from measuring the climb in renunciations rather than skill: a rung can only slow you down if you have the habit it asks you to give up.

I learned to code the old way. I have two decades of reflexes — read the diff, own the function, know how it works inside — and every one of them is a thing the ladder demands I surrender. For me the climb is mostly unlearning. The lower rungs were hard not because the technique was hard but because the identity was.

Someone who learned to build with agents from day one doesn’t have that. They never authored a function alone, never formed the reflex to read every line, never built the search-bar muscle, never tied their self-worth to knowing how the internals work. They don’t climb rungs 1 through 5 so much as start above them — there’s simply nothing there to undo. This is the uncomfortable inversion at the center of the whole framework: seniority is friction. The more experience you have, the more attached you are to exactly the things each rung requires you to drop. The ladder punishes the veteran and waves the newcomer through.

But skipping a rung is not the same as having earned it. The giving-up was never only a loss — each surrender was also where you built the judgment to survive the next one. The veteran who gives up authorship still knows what good code looks like, because reading every diff for twenty years is how they learned it. The newcomer who never authored may direct an app they have no way to evaluate. So skipping rungs is real and it’s an advantage, but it’s a specific one: nothing to unlearn, not automatic competence. Your floor is set by attachment, not ability — and the people with the lowest floor sometimes have the thinnest judgment holding up their ceiling.

Above 12#

The fog is still there. It’s just higher, and there’s a shape in it now.

Two of the candidates I floated in May are still fog: the human decides what “good” means, and human intent at the root of the work. At 11 I still set the measure; at 10 I still state the objective. Nothing in my fleet has pushed on either yet, so by this essay’s own rule I can’t tell you whether they’re rungs or the summit. If I could name them correctly, they wouldn’t be above me.

But the third candidate turned out not to be fog at all. Human accountability for the output. Every commit the fleet makes carries my name — eight thousand of them last month, almost none of which I read. The essays it drafts wait on my byline. That isn’t a thing I’ve refused to give up. It’s a thing nobody can take: the law, the client, and the reader all want a person at the end of the chain, and the fleet is not a person. So the ladder doesn’t fade into fog at the top. It ends at a wall, and the wall isn’t made of technology. Everything below it is procedure.

The whole ladder, in one line, revised: it opens with giving up the search bar, climbs through giving up the code, then your presence, then your judgment — and stops at the one thing that was never yours to give.

— Jed

The ladder, in one image#

The whole thing on a single card — click to open it full size, or save it to share.