What Level Are You Actually At?
Steve Yegge mapped eight levels of AI adoption. Most teams think they're at level five or six. Most teams are at level two. Here's the honest read.
Most engineers think they're using AI well because they use it every day. Using a tool every day is not the same as operating at the frontier of what it can do. There's a gap, and it's bigger than people think.
Here's the answer up front: Steve Yegge mapped eight levels of AI adoption in software development, from "no AI" to "full agentic orchestration." The gap between level two and level six isn't a few new tricks. It's a completely different relationship with what software development actually is.
Most teams are at level two. Some are at three. Very few are past four. And the distance from where most people are to where the frontier is right now is the most underestimated thing in the industry.
Yegge put a number on it. His read of the industry: 20% agentic power users, 20% outright refusers, and 60% still using Cursor or an equivalent chat tool as their ceiling. The 60% in the middle — that's the gap. Those people feel like they're using AI seriously. And relative to the refusers, they are. Relative to the frontier, they've barely started.
A friend sent me a recording of Yegge's talk from a Pragmatic Engineer session in May 2026. I've thought about it almost every day since.
The eight levels, honest
Let me give you the quick version. I'm not going to be precise about every detail — go find the source if you want the exact framing. What I'm going to give you is the honest read.
Levels one through two are where most working engineers live. You use a code completion tool. Copilot, Cursor, whatever. It suggests the next line, sometimes a whole function. You accept or reject. You feel productive. You are more productive.
Level three is where you start using a chat interface for coding help. You describe a problem, you get code back, you edit it, you ship it. This is also where most people hit the ceiling and stop. This feels like "using AI for development." It isn't. It's using AI as a smarter Stack Overflow.
Levels four and five are where agentic use starts. You're not just asking for code — you're asking an agent to navigate a codebase, run tests, make multiple edits, and bring you back a result. Claude Code, Cursor agent mode, similar tools. The agent takes actions. You review outcomes, not steps.
Levels six and seven are where the model actually changes. You're not running one agent. You're running agent fleets. You describe an outcome and multiple agents work toward it in parallel. You're a coordinator now, not a developer in the traditional sense. Yegge called this the "mayor" model. The mayor sets policy and agenda. The agents run the city.
Level eight is full orchestration — agents that discover new tools, spawn subagents autonomously, run their own research and experimentation loops. We have early glimpses of this. It's not the mainstream yet.
Why the gap between three and five is the real one
Most people see the jump from six to eight as the interesting one. The hype is there. But that's not where most people are stuck.
The real gap — the one that matters right now — is between three and five.
Level three feels like AI development. You chat, you get code, you ship it. The workflow is faster, the quality is roughly right, and nothing about how you think about software has changed.
Level five requires a different mental model entirely. You're no longer writing code — you're specifying outcomes and reviewing results. You have to be able to describe what "done" looks like in terms a system can verify. You have to understand failure modes before the agent hits them. You have to build review habits that catch the 20% an agent gets confidently wrong.
That's not a harder version of level three. It's a different skill.
From my own bench
I moved from level three to the beginning of level five about nine months ago. The shift wasn't gradual. It was a threshold.
The thing that broke it open was starting to write specs before I wrote prompts. Once I got into the habit of defining what I actually wanted — verifiable, concrete, specific — the quality of what came back improved dramatically. Not because the model got better. Because I got better at using it.
The skill isn't prompting. The skill is specification. And specification is a skill most developers were never taught to value because the computer used to be able to tolerate vague instructions if you just wrote enough explicit code around them.
That's done now. Precision in description is the new precision in syntax.
Try it today
| Step | What you do | Why it pays off |
|---|---|---|
| 1. Honestly place yourself | Read the level descriptions and answer: where do I actually operate day-to-day, not at my best? | Most people are at level three calling themselves level five. The gap is invisible if you don't name it. |
| 2. Run one level-five task | Pick something real. Write a spec first — plain language, verifiable outcome. Then hand it to an agent. Don't touch the implementation. | Forces the shift from code-author to outcome-specifier. It's uncomfortable the first few times. That's the skill developing. |
| 3. Review the failure | The agent will get something wrong. Diagnose why your spec allowed that failure. Then revise the spec. | The feedback loop is the whole game. This is where you level up. |
Where people get burned
- Confusing tool familiarity with skill depth. Using Claude Code every day doesn't mean you're operating at its frontier. Fix: benchmark against what the tool can do, not what you currently use it for.
- Jumping to level six without nailing five. Agent fleets fail expensively when you don't have strong verification habits yet. Fix: master single-agent review cycles before you scale to parallel runs.
- Treating specification as overhead. "I'll just explain it in the prompt" is a level-three move. Fix: write the spec in a document. If it's too long to write, your task is too big.
- Accepting the first output. Agentic systems are confident. Confidence is not accuracy. Fix: build a habit of checking the output against your spec before you accept it, every time.
Tools, and a question worth sitting with
- A thing to try: Write your next task spec in a plain text document before you open your AI tool. Three sections: goal, constraints, definition of done. Then paste it in. Compare the result to what you'd have gotten from a freehand prompt.
- A watch: Yegge's interview has circulated through the Pragmatic Engineer channel. It's worth a full listen — he's direct about where he thinks most engineers are underestimating the shift. The levels framing starts around 25 minutes in.
- A question to actually sit with: If someone observed how you actually use AI in a normal workweek, what level would they say you're at?
The bottom line
The AI development frontier is further from the average team than the average team thinks. That's not a criticism. It's an opportunity. But you can't close the gap if you don't know it's there.
Most people are at level three. Level five is where the real productivity change lives. The gap between them is a skill, and the skill is learnable.
— Dru Edwards