Everyone’s talking about AI and coding. “AI will replace developers.” “AI is just autocomplete.” “We’re years away from anything real.” “The future is already here.”
The conversation is stuck because we don’t have shared language for what we’re actually discussing. People saying “AI coding” could mean anything from GitHub Copilot suggesting function completions to fully autonomous systems building applications from scratch.
Here’s a framework that might help: four levels of AI-assisted development, ordered by how much the human stays in the loop.
Level 1: Human-Only Coding
The baseline. Human writes every line of code.
This was the default from the 1960s through roughly 2020. The human does all the thinking and all the typing. Tools help with productivity—IDEs, linters, type checkers, debuggers—but the AI contribution is zero. Every character in the codebase came from human fingers.
Bottleneck: Human typing and thinking speed. If you want more code, you need more humans or more hours from existing humans.
Skills that matter: Coding ability. Deep language/framework expertise. Problem-solving. All the classic developer skills.
This is still where most software in production was built. The vast majority of code running in the world today was written by humans without AI assistance.
Level 2: AI-Assisted Coding
The Copilot era. AI suggests completions, human accepts or rejects.
This began in earnest around 2021 with GitHub Copilot. The AI watches what you’re typing and suggests what might come next—sometimes a single line, sometimes an entire function.
The human is still writing code, just faster. You type function calculateTax( and the AI suggests the implementation. You review it, hit Tab if it looks right, or keep typing if it doesn’t.
Bottleneck: Still human decision-making on every line. The AI proposes; you dispose. Each suggestion requires you to evaluate: Is this correct? Does it match my intent? Are there edge cases it missed?
The key insight: Level 2 gives you faster typing but the same thinking. You’re still making every architectural decision, every design choice, every judgment call. You just get there with fewer keystrokes.
Skills that matter: Same as Level 1, plus the ability to evaluate AI suggestions quickly. Knowing when the AI is wrong becomes a skill. The best Level 2 users develop good intuition for when to trust and when to verify.
Most developers who “use AI” today are operating at Level 2. They have Copilot or Cursor enabled, it helps them write code faster, but they’re still fundamentally in control of every line.
Level 3: Human-Directed AI Coding
The orchestration era. Human defines what to build, AI handles how.
This is where things get interesting. The human steps up a level of abstraction. Instead of writing code and having AI assist, you describe what you want and the AI writes the code.
The tools are different: Claude Code, Cursor Composer, Aider. The interaction pattern is different: you give instructions, the AI executes, you review the output.
“Add a user authentication system with email/password login and OAuth support.” The AI writes the routes, the database schema, the frontend forms, the tests. You review, provide feedback, iterate.
Bottleneck: Human requirements quality and review capacity. The AI will build whatever you tell it to—including the wrong thing if your requirements are unclear. And you need to review everything that comes back, which limits throughput.
The key insight: Leverage shifts from typing to thinking. The skill that matters isn’t how fast you can write code—it’s how clearly you can define what needs to be built and how effectively you can review what the AI produces.
Skills that matter: Requirements definition. System design. Quality judgment. Orchestration. You need to be technical enough to review AI output, but the bottleneck is no longer coding ability.
This is where I operate with the 8-agent SDLC system. I’m not writing most of the code line by line. I’m defining requirements, reviewing architecture decisions, inspecting implementations, and making judgment calls. The AI does the building; I do the directing.
We are at Level 3. Most people in the conversation don’t realise this. They think Level 2 is the current state of the art, that AI coding means “Copilot but better.” But the tools for Level 3 exist now. They work. The one-person development army is already possible.
Level 4: Full AI Teams
The autonomy era. Human sets goals, AI handles everything.
At Level 4, the human defines objectives at a high level—“build me an invoicing system for small businesses”—and the AI handles everything: breaking down the goal into tasks, designing the architecture, implementing features, writing tests, deploying, and iterating.
Human involvement becomes strategic and supervisory. You set direction, review high-level decisions, and course-correct when needed. But you’re not reviewing individual code changes or making implementation decisions.
Bottleneck: AI judgment, reliability, and context management. The AI needs to make good decisions autonomously—not just technically correct decisions, but decisions that balance tradeoffs appropriately. It needs to detect its own mistakes and fix them. It needs to maintain coherent understanding across a project.
What needs to be true for Level 4:
- Reliability. Low hallucination rates. When the AI produces code, it needs to be correct enough that autonomous operation doesn’t create disasters.
- Persistent context. Project-scale memory. The AI needs to understand the entire codebase, its history, and the decisions that led to its current state.
- Self-correction. The ability to detect errors and fix them without human intervention. Run tests, identify failures, debug, fix.
- Judgment. Making good tradeoffs. Knowing when to prioritise speed vs. quality, when to refactor vs. ship, when something needs human escalation.
Level 4 isn’t here yet. Current AI systems hallucinate too much for fully autonomous operation. Context windows limit project-scale understanding. AI struggles with ambiguous requirements and makes mistakes that require human judgment to catch.
But I can see Level 4 from where I’m standing. It’s not a distant science fiction future—it’s maybe a year or two away for certain types of work. Greenfield projects with well-defined scope will get there first. Maintenance of complex legacy systems will take longer.
The Transitions
Each level transition represents a fundamental shift in the human’s role:
| Transition | Human Role Shift | New Bottleneck |
|---|---|---|
| 1 → 2 | Typist → Selector | Decision fatigue from constant evaluation |
| 2 → 3 | Selector → Director | Requirements quality and review capacity |
| 3 → 4 | Director → Strategist | Goal clarity and outcome validation |
The skills that make you successful at one level don’t automatically transfer to the next. A great Level 1 coder might struggle at Level 3 if they can’t step back from implementation details. A great Level 3 director might struggle at Level 4 if they’re not comfortable with less control.
Why This Matters
Different levels require different skills. If you’re optimising for Level 2 (faster coding), you’re building the wrong muscles for Level 3 (better requirements and orchestration). Understanding where you are helps you invest in the right capabilities.
Organisations are at different levels. And that’s fine. A bank with heavy compliance requirements might appropriately stay at Level 2 for longer. A startup moving fast might jump to Level 3 immediately. There’s no single “right” level—there’s the level that matches your context.
The winning skillset changes. At Level 1, the best developers are the ones who write the best code. At Level 3, the best developers are the ones who write the best requirements and make the best judgment calls on AI output. At Level 4, the best developers will be the ones who set the clearest goals and validate outcomes most effectively.
PM skills become more valuable as you climb. This is the thesis I keep returning to: the skills that product managers build—requirements definition, systems thinking, quality judgment—are exactly the skills that matter more at higher levels. The “Technical PM” skillset that felt like an awkward in-between at Level 1 becomes the optimal profile at Level 3.
Where You Should Be
This depends on your context:
Solo devs and indie hackers: Level 3 is accessible now. The tools exist. The leverage is real. If you’re still operating at Level 2, you’re leaving significant productivity on the table.
Startups: Level 3 as default, with selective Level 4 experiments for well-defined projects. Move fast, but keep humans in the loop for anything critical.
Enterprise: Level 2 to 3 transition, proceeding with appropriate caution. The risk profiles are different. Code review processes, compliance requirements, and change management all need to adapt.
The future: Level 4 for greenfield projects with clear scope. Level 3 for ongoing maintenance and complex changes. Level 2 as a fallback for domains where AI judgment isn’t reliable enough.
A Note on Level 4 Skepticism
Some people think Level 4 is hype—that we’ll never get there, or that it’s decades away.
I don’t think so. The gaps between current AI and Level 4 are substantial but specific: reliability, context, self-correction, judgment. These are engineering problems, not fundamental barriers. Progress on them is measurable.
Devin and similar attempts at autonomous coding agents are early and rough. They fail more than they succeed. But they fail in instructive ways—ways that point toward what needs to improve.
Others think Level 4 is around the corner—that we’ll wake up one day and AI will be building production software autonomously.
I don’t think that either. The current limitations are real. Hallucination isn’t solved. Context management at project scale isn’t solved. The judgment calls that experienced developers make intuitively—when to refactor, when to ship, when to push back on requirements—aren’t something current AI does reliably.
My honest assessment: Level 4 for constrained, well-defined greenfield projects within 1-2 years. Level 4 for complex enterprise systems with legacy codebases: longer.
Closing Thought
The levels are not value judgments. Higher isn’t automatically better. The right level depends on your context, your risk tolerance, your team’s skills, and the type of work you’re doing.
But knowing where you are—and where the field is going—helps you make better decisions. About what skills to build. About what tools to invest in. About how to structure your work.
We’re at Level 3. Most people don’t realise it yet. The leverage is available now, for those who understand how to use it.
This is Part 3 of a series on AI-assisted software development. Previously: The 8-Agent SDLC. Next: You Don’t Need Kubernetes.