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 two halves and two thresholds.
In the first half, 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 half, 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 important one, and it’s 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. 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.
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.
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. 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 nine 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.
10+
There is a rung above 9. I can’t tell you what it is.
That’s not a dodge — it’s the most rigorous thing on this page. Look at the pattern. Every rung gives up something the rung below it considered non-negotiable. Ask the Reviewer at rung 3 to imagine giving up reading the diff and they’ll tell you that’s the whole job. Ask the Bottleneck at rung 7 to imagine being unreachable and they can’t even parse it. From inside any rung, the next surrender is invisible, because you are still standing on the thing you’re about to give up. A ladder that could name its own summit would be lying about how the first nine rungs felt before anyone had climbed them.
So 10 is defined by its shape, not its content: it is whatever still feels load-bearing at rung 9 — the thing I’d resist giving up hardest, the pillar I can’t currently see as a pillar. That gives a clean test, and the test is what makes 10 honest. A candidate only qualifies as level 10 if, standing at 9, it still feels indispensable. Which is exactly why “fleets that assign their own work” or “fleets that tune themselves” aren’t it — I can already picture those. They’re just more of 9. The real one is something I’d argue with you about. Maybe it’s human intent at the root of the work. Maybe it’s human accountability for the output. Maybe it’s the human as the one who still decides what “good” means. I won’t commit to any of them, because if I could name it correctly, it wouldn’t be 10.
I haven’t reached it. I don’t know anyone who has. On the map it isn’t an arrow — an arrow would mean I know which way is up. It’s fog above the tree line. You can see the mountain keeps going. You can’t see the next ledge, or even where it sits.
If you can name the thing rung 9 still can’t function without — the necessity none of us can see because we’re all still standing on it — then you might be the first one looking at level 10.
The whole ladder, in one line: it opens with giving up the search bar, and it ends — if it ends — with giving up something I’m not yet wise enough to miss.
— Jed
The ladder, in one image
The whole thing on a single card — click to open it full size, or save it to share:
