A Five-Level Maturity Model for Agentic Coding: From Copilot to Code Production Systems
> Note: This is not a product introduction, but a cognitive map. The value of a map lies not in telling you what exists somewhere, but in showing you which level you currently occupy—and where the next level is.
---
1. Why Single-Point Analysis Falls Short
In 2024-2025, AI coding tools appeared at a remarkable pace: GitHub Copilot, Cursor, Claude Code, Codex CLI, Devin, OpenAI's Symphony architecture, Ryan Lopopolo's Harness Engineering…
Every individual analysis answers the same question: "What can this tool do?"
But this question hides a trap—it assumes all tools are doing "the same thing" at different degrees. In reality, they operate at different levels. Comparing Devin and Copilot on "who writes code faster" is like comparing a bicycle and a high-speed train on "which transports better"—the dimension is wrong.
We need a layered framework so every piece of work finds its floor.
---
2. The Five-Level Model
| Level | Name | Core Trait | Human Role | AI Role | Representative Products | |-------|------|-----------|------------|---------|------------------------| | L1 | Assisted Programming | AI completes code the human is writing | Leader | Assistant | GitHub Copilot, Codeium | | L2 | Conversational Coding | AI understands context; humans guide via dialogue | Director | Executor | Cursor Chat, GitHub Copilot Chat | | L3 | Autonomous Task Execution | AI independently completes specific tasks (file/module level) | Approver | Autonomous agent | Claude Code, Codex CLI, Aider | | L4 | Multi-Agent Orchestration | AI decomposes complex tasks, coordinates multiple agents | Architect | Coordinator | Devin, Symphony (OpenAI), Multi-agent IDEs | | L5 | Code Production Systems | AI designs and runs the code factory; humans define intent and constraints | Governor | System designer | Harness Engineering |
> Key insight: Level transitions are not quantitative (faster, more accurate) but qualitative (relationship restructuring). L1→L2 changes the interaction mode; L2→L3 changes the trust structure; L3→L4 changes the organization; L4→L5 changes the anchor of value.
---
3. Bottleneck Metrics Between Levels
L1→L2: Depth of Context Understanding
- Metric: How much code context the AI can understand, and cross-file correlation ability
- Status: Copilot's context window is roughly 2k-8k tokens; Cursor extends to file level via codebase indexing
- Breakthrough signal: When AI can proactively ask, "You want to modify this function, but it's called in three places—are you sure?"
- Metric: End-to-end success rate of task completion without human intervention
- Status: Claude Code scores roughly 49%-75% on SWE-bench but still needs human confirmation at key points
- Breakthrough signal: When humans shift from "turn-by-turn guidance" to "issue a task once and wait for results"
- Metric: Ability to split complex requirements into parallelizable subtasks, and information-sync efficiency among sub-agents
- Status: Devin can plan multi-step tasks but with low coordination efficiency; Symphony drives multiple agents via a Linear board but remains early-stage
- Breakthrough signal: When multiple agents can autonomously assign work, resolve conflicts, and merge code like a team
- Metric: AI designs not "features" but "production systems"—processes, quality standards, feedback loops
- Status: Ryan Lopopolo's Harness Engineering is the first engineering practice explicitly pointing at L5
- Breakthrough signal: When AI can say, "This module's code quality has degraded; I suggest refactoring, and here is an auto-generated refactoring plan"
- Explainable execution logs (not "I changed the code" but "why I changed it, what changed, and the blast radius")
- Automatic rollback (self-recovery from bad changes)
- Human-configurable "trust thresholds" (low-risk changes auto-approved; high-risk changes require approval)
- Precise mapping from natural-language intent to system constraints
- Verifiable intent-consistency checking (ensuring generated systems actually implement the intent)
- Intent version management (how systems gracefully evolve when intent changes)
- Ryan Lopopolo, "Harness Engineering" (AI Engineer Summit 2025)
- OpenAI Symphony Architecture (Linear-driven multi-agent workflow, Elixir/BEAM)
- Anthropic Claude Code & Codex CLI documentation and benchmarks
- Cognition Labs Devin technical reports
- Cursor Composer mode and parallel agent design
- SWE-bench and agentic coding evaluation frameworks
L2→L3: Autonomy and Trust
L3→L4: Task Decomposition and Coordination
L4→L5: System Design Capability
---
4. Who Is Attempting to "Jump Levels"
Jumping a level is 10x harder than competing within one, because it requires redesigning the human-machine relationship.
| Product | Current Level | Target | Strategy | Risk | |---------|---------------|--------|----------|------| | Cursor | L2 | → L3 | Composer mode (8 parallel agents) | Coordination logic for parallel agents is still human-designed; not truly autonomous | | Claude Code | L3 | → L4 | Multi-file editing and tool invocation | Lacks built-in task decomposition and sub-agent management | | Devin | L4 | → L5 | Autonomous planning + sandboxed execution | Insufficient system-design depth; more "capable generalist" than "factory designer" | | OpenAI (Symphony) | L4 | → L5 | Linear-board-driven multi-agent + BEAM concurrency | Highly dependent on internal infrastructure; unclear generalization path |
> One judgment: Cursor's Composer mode is the most underrated level-jumping attempt. 8 parallel agents + git worktrees essentially solve the L3→L4 coordination problem with engineering means—not by making AI smarter, but by making the system smarter.
---
5. A Shared Blind Spot: Everyone Assumes Code Is the Goal
The five-level model has a hidden assumption: the output at every level is code. But Ryan Lopopolo's Harness Engineering proposes a more radical view:
> Code is consumable; the SPEC is the asset.
This means the five-level model may be only a "transitional path"—the true endpoint is not "AI producing better code" but "AI generating runnable systems directly from intent, with code as an invisible intermediate artifact."
If this blind spot is broken, the five-level model becomes a historical relic—just as we no longer describe the high-speed rail era with "horse carriage speed tiers."
---
6. Prediction: Where the Next Breakthrough Lies
Three most likely directions based on current trends and bottlenecks:
1. L3 "Trust Infrastructure"
Claude Code and Codex CLI are established at L3; the next step is not higher accuracy but reducing human approval burden. This requires:
2. L4 "Orchestration Abstraction Layer"
Symphony and Devin both do multi-agent, but their implementations are highly coupled. An orchestration protocol independent of specific agents is needed—like Kubernetes not caring what containers you run. Once this abstraction appears, L4 shifts from "a few companies' internal capability" to "industry infrastructure."
3. L5 "Intent Compiler"
Harness Engineering's ultimate goal is not more AI-written code, but AI understanding "what humans want" and generating systems directly. This requires:
---
7. Conclusion
The five-level model is not truth, but a thinking tool. Its value:
1. Positioning: Which level is your tool at? What problem does it solve? 2. Choice: If you need L3 capability, Cursor's L2+ jump may be unstable; if you need L4, Devin suits better than Claude Code. 3. Anticipation: When someone says "AI will replace programmers," ask "at which level?" The answers for L1 and L5 are completely different.
The real revolution of agentic coding is not any single tool writing faster, but the entire software production paradigm moving up a floor. The human role changes at every level, but one thing remains—
> Defining "what to do" is still human.
AI's precision at "how to do it" keeps improving, but the sense of direction—"why do it"—remains, for now, human territory.
---