We’re living inside a strange split-screen reality.
On one side: a handful of teams are running lights-out software factories — specs go in, working software comes out.
On the other: many developers adopt AI tools and get slower, at least at first, while telling themselves they’re faster.
That gap isn’t a model problem. It’s not even a tooling problem.
It’s a workflow + specification problem.
Dan Shapiro (CEO of Glowforge) published a framework earlier this year that finally gives honest language for where you actually are. He calls it the five levels of vibe coding. I like it because it cuts through the marketing fog.
I’ll lay out Shapiro’s levels (0 → 5), then add the additional level we’ve been using — the one that explains why this isn’t just a coding story.
The five levels of vibe coding run from Level 0 (spicy autocomplete, where AI just reduces keystrokes) up to Level 5 (the dark factory, where specs go in and working software comes out with no human writing or reviewing code). Most teams who call themselves “AI-native” are actually at Level 2 — reviewing multi-file output but still reading the code. The real ceiling isn’t coding skill; it’s whether you can write a specification and an eval strict enough that a machine can’t misinterpret it. And the same ladder now applies to every knowledge function, not just engineering.
Level 0 — Spicy Autocomplete
This is Copilot-as-tab-key: you type, the AI suggests the next line, you accept or reject.
You’re still writing the software. The AI is reducing keystrokes.
Useful? Yes. Transformational? Not yet.
Level 1 — Coding Intern
You hand the AI a discrete, well-scoped task:
- “Write this function”
- “Build this component”
- “Refactor this module”
The AI does the task. You review everything.
The human still owns architecture, judgment, and integration — the parts interns can’t be trusted with.
Level 2 — Junior Developer
The AI can now operate across files and dependencies. It navigates a codebase and delivers multi-file changes.
You’re reviewing more complicated output, but you’re still reading the code.
Shapiro’s (provocative but accurate) claim: a huge fraction of people who call themselves “AI-native” are operating here.
This level is why entry-level roles get squeezed first: Level 2 is literally “junior developer as a service.”
Level 3 — Manager
This is where the relationship flips.
You’re no longer coding with AI help. You’re directing the AI, and it submits pull requests for your approval.
Your day becomes: review, approve, reject — at the feature / PR level.
Shapiro points out a real ceiling here: many developers stall at Level 3 because letting go of the code is psychologically hard. They can delegate, but they don’t trust what they can’t see.
Level 4 — Product Manager
Now you write a spec, walk away, come back hours later, and check whether the tests pass.
You largely stop reading code. The code becomes a black box.
You care about outcomes, not implementation — because your specification and evaluation are complete enough that “passes” actually means “works.”
This level is rare today because it requires a skill almost nobody has built deliberately: writing specs and evals that an autonomous system can satisfy without supervision.
Level 5 — Dark Factory
This is the end-state Shapiro names explicitly: a black box that turns specs into working software.
No human writes the code.
No human reviews the code.
The factory runs with the lights off: specification goes in, working software comes out.
Almost nobody operates here today. But it’s where the industry is heading — because once Level 4 is real, Level 5 is a systems problem, not a model problem.
Level 6 (The One Added to the List) — Vibe Work / The Dark Office
Shapiro’s framework describes what happens inside engineering.
Level 6 is what happens when the same shape hits every knowledge function: marketing, finance, legal, recruiting, strategy, operations.
It’s the same factory pattern — just with different outputs:
- Specs → campaigns, with conversion and brand evals
- Specs → forecasts, with backtests and audit trails
- Specs → hiring pipelines, with rubrics and bias checks
- Specs → policies, with compliance and exception handling
In other words: vibe coding is the most visible case of vibe work.
And this is where the tsunami lives: not “AI replaces your job”, but “AI replaces unstructured production tasks” — and pushes humans up the stack into specification, judgment, and accountability.
The real bottleneck isn’t coding. It’s specification.
Level 2 automation is cheap.
Level 4 reliability is expensive — because it forces you to answer questions most teams avoid:
- What does “done” mean in testable terms?
- What are the failure modes and edge cases?
- What are the stop conditions where the system must escalate?
- What metrics define “working” versus “merely plausible”?
At Level 4 and Level 5, the highest-leverage engineer isn’t the fastest typist.
It’s the person who can write a spec so clear that a machine can’t misinterpret it — and an eval so strict that passing means the customer is safe.
How to move up one level (without pretending you’re already there)
If you want to climb Shapiro’s ladder — or apply it to non-coding work — try this:
- Name your current level honestly. Most teams are between Level 0 and Level 3. That’s fine. It’s just important to stop calling Level 2 “agentic development.”
- Turn “requirements” into tests. Every vague phrase (“make it better”) should become a check, a metric, an example, or a constraint.
- Build a review harness. PR review (Level 3) is a harness. Tests + evals (Level 4) are a harness. Monitoring + rollback (Level 5) are a harness.
- Capture what works as playbooks. The moment a workflow succeeds twice, it stops being a prompt and becomes an organizational asset.
Vibe coding isn’t the trend.
The trend is that every knowledge worker becomes a spec-writer and an evaluator — a manager of increasingly autonomous factories.
So the question isn’t “Are you vibe coding?”
It’s: Which level are you operating at — and what would make Level+1 real in the next 30 days?
Frequently asked questions
What are Dan Shapiro’s five levels of vibe coding? Level 0 is spicy autocomplete (AI reduces keystrokes); Level 1 is the coding intern (discrete, well-scoped tasks you fully review); Level 2 is the junior developer (multi-file changes you still read); Level 3 is the manager (you review and approve pull requests); Level 4 is the product manager (you write a spec, walk away, and check whether the tests pass); and Level 5 is the dark factory (specs in, working software out, with no human writing or reviewing code).
What level of vibe coding are most developers actually at? Most are between Level 0 and Level 3, and a large share of people who call themselves “AI-native” are really at Level 2 — delivering multi-file changes but still reading the code. Many stall at Level 3 because letting go of the code is psychologically hard: they can delegate, but they don’t trust what they can’t see.
What is vibe work? Vibe work is the “Level 6” extension of the framework: the same spec-to-output factory pattern applied beyond engineering to marketing, finance, legal, recruiting, strategy, and operations. Specs become campaigns with conversion evals, forecasts with backtests, hiring pipelines with rubrics, policies with compliance checks. Vibe coding is simply the most visible case of it.
How do I move up a level in AI-assisted work? Name your current level honestly, turn vague requirements into tests (every “make it better” becomes a check, metric, example, or constraint), build a review harness appropriate to the level (PR review, then tests plus evals, then monitoring and rollback), and capture what works as playbooks. The binding constraint isn’t typing speed — it’s writing a spec a machine can’t misinterpret and an eval strict enough that passing means the customer is safe.
Samuel Pouyt is a geopolitical risk analyst and technologist. He writes about specification, judgment, and decision-making in the age of AI.