5 Levels of AI-Driven Software Development: Where Do You Stand?

Andrej Karpathy recently rated 342 jobs by how much AI will change or displace them. The result: software developers land at 8 to 9 out of 10 (Source: Deeper Insights / Karpathy, 2026). Not surprising and alarming at the same time.
That sounds threatening, but it mainly means the jobs are transforming, not disappearing. Things will definitely be different.

I personally also believe that the job “programmer” is history. The traditional “software developer” role will largely dissolve, because raw code output is increasingly handled by AI. What remains and even grows in importance: human judgment on architectures and complex interdependencies, communication with stakeholders, translating between business and technology. The job doesn't disappear, it transforms into a role that demands far more coordination, more human-to-human interaction than today. By the way: Karpathy ranked a roofer at less than 2 in the same article. That shows the gap between jobs and how differently exposed we all are.

I've been working on this topic for years and switched my entire workflow to agentic work over the last year. There are now plenty of articles describing hierarchies and learning curves for AI adoption.
But most of them miss the point, in my view. They don't describe what I actually see in my day-to-day work. So I developed my own five-level hierarchy. The interesting part: many people are stuck at level 1 or 2, maybe at 2.5 thanks to Copilot. But levels 4 and 5 are where it really gets interesting.

Level 1: The One-Liner

Level 1 is simple: you open ChatGPT, ask a question, get a result. At worst, the AI is a slightly better search engine. Sure, you can say “write me a summary” or “write me an Instagram post.” The problem: the AI doesn't know your project, there's no context. The result falls far short of what you actually need.

Telling in this regard are the METR studies: in their first round (early 2025), experienced developers were 19% slower with AI, yet believed they were 20% faster (Source: METR, 2025). In the February 2026 follow-up, a subset of the original developers were suddenly 18% faster. First slower, then faster. What changed? The people learned when AI helps and when it gets in the way. The time loss at level 1 comes from constant fixing and correcting. You adopt AI, think you're doing the right thing, and end up worse off than before. That's exactly the trap to avoid.

Level 2: Structured Templates

At level 2 things get noticeably more structured. You use concrete prompt templates: longer, more complex, with real context. And often even more important: they define what you don't want. That has a massive impact on quality.

The problem: you're still the bottleneck. You have to have the idea, find the right prompt, copy everything into the chatbot, fire it off, review the result. That is an acceleration, because you get tasks done that used to take two hours. Helpful, but not a revolution. Maybe an evolution.
And at this point you start asking: where's the promised leverage? It's nice, it helps, it saves time. But where's the actual transformation?

Level 3: Project DNA

From level 3 it gets interesting. Here you provide the AI with concrete context: files and folders containing project knowledge, branding kits, press kits, past conversations, documented decisions. The AI no longer answers an isolated question. It answers your question taking the entire project into account. That changes the situation fundamentally, because now you can actually delegate complete tasks and review the results afterward.

The Productivity Paradox

Here an illuminating paradox emerges. The DORA Report shows: 95% of respondents use AI, and more than 80% report productivity gains. Another study confirms: 21% more tasks, 98% more PRs. But actual speed at the organizational level, at the team level, at the project level? Output remained nearly constant (Source: Faros AI / DORA Report, 2025).

Developers produce twice as much, but overall delivery doesn't follow. Why? My guess: things start grinding at the edges. Picture an engine that suddenly revs higher while the transmission and drivetrain can't keep up. The speed never reaches the road.

And that's the crucial point: “AI-assisted development” is actually a misnomer. It's not just about AI-driven development, it's about an AI-driven organization. That sounds like a subtle difference, but it's fundamental. AI-driven development without an AI-driven organization doesn't work: the performance never reaches the road. You think you're doing the right thing, try to accelerate, but the extra output gets lost along the way.

Levels 4 and 5: Agents and Orchestrated Teams

This is where agents come in, where you can hand off complete tasks. And where the real leverage emerges.

What does an AI-driven organization actually mean? It means moving beyond individual agents handling isolated tasks, toward building complete teams and departments in an agentic way. Or at least integrating the agentic part so deeply that AI becomes like electricity: it's just there, everything flows through it. And at that point the bottlenecks start to dissolve.

What does that look like in practice? There are planner agents, architects, implementation agents, testers, reviewers. But not just in development: design and marketing agents can also be embedded in the organization, truly collaborating with each other. Anthropic's “Agentic Coding Trends Report 2026” describes exactly this development: agents no longer work for minutes on isolated tasks, but for hours on entire systems (Source: Anthropic, 2026).

Concrete example: a feature request “customer management with role-based access control.” The research agent analyzes the current codebase: where do we connect, which elements already exist? Then the architect takes over, builds a development plan, checks which modules are affected, and weaves the extension into the project DNA: documented decisions, project history, architectural principles. Then it gets implemented, tested, reviewed, and automatically routed through a QA pre-check. Final sign-off should be human, but where exactly you draw that line is its own discussion.

None of these agents is omniscient. Each does exactly what it's specialized for and encapsulates the necessary knowledge. The system can learn over time: refine skills, branch off metrics, build feedback loops. The design space is enormous.

What Separates the Levels

Below level 3, the advantage is pure speed: you do tasks faster, but still yourself. From level 3, that changes fundamentally. It's no longer about working faster. It's about delegating tasks to the AI system.

And here lies the crucial distinction: it's human judgment that makes the difference. The judgment that says: “I like this plan” or “the solution is good, I'll sign off.” You still need to know what you're doing as a human, to put it mildly.

You can try to abstract your knowledge, pack your judgment into pipelines, and produce results almost factory-like. But it's still human judgment, human taste, that forms the quality gate the machine has to meet.

Think of Rick Rubin, the music producer: he doesn't play instruments, but knows exactly what he wants. Every album sounds like his vision. That's the essence from level 3 on: you don't do it yourself anymore, you delegate. But it's your vision, your why, that drives the decisions and should set the quality gate.

Without that human steering, you end up in the infamous AI slop: volume without substance, because the machine can produce but not judge. Of course an AI can write vast amounts of source code. That doesn't mean it's good. It's the interplay between human and machine that counts. Like Rick Rubin, who knows what emotion the music should evoke. The same applies to software development.

According to the World Economic Forum, 37 percent of developers say AI has already expanded their career opportunities (Source: World Economic Forum, 2026). The willingness is there. What's missing is the leap from tool to system.

Concrete Next Steps

How do you get there? The simplest first step: sit down for an afternoon and write templates. Away from “generate me a text for...” toward concrete specifications: what should the result contain, what explicitly not?

Next step: what's missing from those templates? Where does shared knowledge about your company, your project, your brand live? What are your stylistic choices? Abstracting that knowledge is the truly demanding part. But once you've done it, the combination of abstracted knowledge and template prompts yields significantly more specific results.

After that it gets more technical: what individual tasks do I have? What concretely needs to happen? Which modules are involved, which functions get called? For levels 4 and 5, this has to be systematically worked through and orchestrated into pipelines. At level 5, the system gains memory: self-learning components, automatic feedback, continuous self-optimization.

The Window

Anyone at level 3 or above right now is in the minority. That's precisely the opportunity: the head start grows every month. Many people stay stuck at level 1 and 2, at 2.5. There seems to be something like a sound barrier.

All the more important to take this shift now. The shift from “I work myself, just faster” to “I delegate, review, and am the heart and soul of my work.” That's a fundamentally different way of working, with two components: learning the craft and internalizing the new mindset. It doesn't happen overnight. That's exactly why it's worth starting now, so your own learning curve can build momentum.