Agentic Coding Five-Layer Maturity Model: From Copilot to Code Production Systems

Reference perspective: This is not a product introduction, but a "cognitive map." The value of a map is not in telling you what exists somewhere, but in showing you which layer you currently stand on—and where the next layer is.

---

1. Why Single-Tool Analysis Isn't Enough

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, and more.

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 layers. 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 can find its floor.

---

2. The Five-Layer Model

| Layer | 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 and coordinates multiple agents | Architect | Coordinator | Devin, Symphony (OpenAI), Multi-agent IDE | | L5 | Code Production System | AI designs and runs the code factory; humans define intent and constraints | Governor | System designer | Harness Engineering |

> Key insight: Layer 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 for Each Layer

L1→L2 bottleneck: depth of context understanding

• Metric: Length of code context the AI can understand and cross-file association ability
• Status: Copilot's context window is roughly 2k–8k tokens; Cursor extends to file level via codebase indexing
• Breakthrough signal: When the AI proactively asks, "You want to modify this function, but it's called in three places—are you sure?"

L2→L3 bottleneck: autonomy and trust

• Metric: End-to-end success rate of AI completing tasks without human intervention
• Status: Claude Code scores roughly 49%–75% on SWE-bench, but still needs human confirmation at critical points
• Breakthrough signal: When humans shift from "turn-by-turn guidance" to "issue the task once and wait for the result"

L3→L4 bottleneck: task decomposition and coordination

• Metric: Ability to split complex requirements into parallelizable subtasks, and information-sync efficiency among sub-agents
• Status: Devin can plan multi-step tasks but coordinates inefficiently; Symphony drives multiple agents via a Linear board but is still early-stage
• Breakthrough signal: When multiple agents can autonomously assign work, resolve conflicts, and merge code like a team

L4→L5 bottleneck: system design capability

• Metric: The AI designs not "features" but a "production system"—including processes, quality standards, and feedback loops
• Status: Ryan Lopopolo's Harness Engineering is the first engineering practice explicitly pointing to L5
• Breakthrough signal: When the AI can proactively say, "This module's code quality is degrading; I suggest refactoring, and here's an auto-generated refactoring plan"

---

4. Who Is Attempting "Layer Jumps"

Jumping layers is 10x harder than competing within a layer, because it requires redesigning the human-machine relationship.

| Product | Current Layer | Jump Direction | Strategy | Risk | |------|---------|---------|------|------| | Cursor | L2 | → L3 | Composer mode (8 parallel agents) | Coordination logic of parallel agents is still human-designed; not truly autonomous | | Claude Code | L3 | → L4 | Multi-file editing and tool calling | Lacks built-in task decomposition and sub-agent management | | Devin | L4 | → L5 | Autonomous planning + sandboxed execution | Insufficient depth in system design; more a "capable generalist" than a "factory designer" | | OpenAI (Symphony) | L4 | → L5 | Linear-board-driven multi-agent + BEAM concurrency | Highly dependent on internal infrastructure; path to generalization unclear |

> A judgment: Cursor's Composer mode is the most underrated layer-jump attempt. 8 parallel agents + git worktrees is essentially solving the L3→L4 coordination problem with engineering means—not by making the AI smarter, but by making the system smarter.

---

5. A Shared Blind Spot: Everyone Assumes Code Is the Goal

The five-layer model carries a hidden assumption: the output at every layer 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-layer model may just be a "transitional path." The real 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 through, the five-layer model becomes a historical relic—just as we no longer describe the high-speed rail era using "horse-drawn carriage speed tiers."

---

6. Prediction: Where Will the Next Breakthrough Come From

Based on current trends and bottleneck analysis, three most likely directions:

1. "Trust infrastructure" at L3

Claude Code and Codex CLI have established themselves at L3; the next step is not improving accuracy but reducing the human approval burden. This requires:

• Explainable execution logs (not "I changed the code," but "why I changed it, what I changed, and the impact scope")
• Automatic rollback mechanisms (self-recovery when changes break things)
• Human-configurable "trust thresholds" (low-risk changes auto-approved, high-risk changes require approval)

2. "Orchestration abstraction layer" at L4

Symphony and Devin both do multi-agent, but their implementations are highly coupled. The industry needs an orchestration protocol independent of specific agents—like Kubernetes, which doesn't care what containers you run. Once this abstraction layer appears, L4 will shift from "internal know-how of a few companies" to "industry infrastructure."

3. "Intent compiler" at L5

Harness Engineering's ultimate goal is not to make AI write more code, but to make AI understand "what humans want" and generate systems directly. This requires:

• Precise mapping from natural-language intent to system constraints
• Verifiable intent-consistency checks (ensuring the generated system truly implements the intent)
• Intent version management (how the system evolves gracefully when intent changes)

---

7. Conclusion

The five-layer model is not truth, but a thinking tool. Its value:

1. Positioning: Which layer is your tool on? What problem does it solve? 2. Choosing: If you need L3 capability, Cursor's L2+ jump attempt may be unstable; if you need L4, Devin may fit better than Claude Code. 3. Predicting: When someone says "AI will replace programmers," ask "at which layer does that replacement happen?" The answers at L1 and L5 are completely different.

The real revolution of agentic coding is not that some tool writes faster, but that the entire floor of the software production paradigm is moving upward. The human role changes on every floor, but one thing stays constant—

> Defining "what to do" remains a human job.

AI's precision on "how to do it" keeps improving, but the sense of direction—the "why do it"—remains, for now, human territory.

---

Sources

• 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