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

Reference perspective: This is not a product introduction, but a *cognitive map*. A map's value is not in telling you what exists somewhere, but in showing you which floor you currently stand on—and where the next floor is.

---

1. Why Single-Point Analysis Isn't Enough

In 2024–2025, AI coding tools emerged at a staggering pace: GitHub Copilot, Cursor, Claude Code, Codex CLI, Devin, OpenAI's Symphony architecture, Ryan Lopopolo's Harness Engineering...

Each individual analysis report answers the same question: "What can this tool do?"

But this question carries a hidden trap—it assumes all tools are doing "the same thing," just at different degrees. In reality, they are doing things 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"—wrong dimension entirely.

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 a human is writing | Leader | Assistant | GitHub Copilot, Codeium | | L2 | Conversational Coding | AI understands context; human directs 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: Layer transitions are not quantitative change (faster, more accurate) but qualitative change (relationship restructuring). L1→L2 changes the interaction mode; L2→L3 changes the trust structure; L3→L4 changes the organization; L4→L5 changes the value anchor.

---

3. Key Bottleneck Metrics Between Layers

L1→L2 Bottleneck: Context Understanding Depth

• Metric: Length of code context AI can understand, and cross-file association capability
• Status: Copilot's context window is roughly 2k–8k tokens; Cursor extends to file level via codebase indexing
• Breakthrough signal: When 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's SWE-bench scores are roughly 49%–75%, but humans still confirm at key checkpoints
• Breakthrough signal: When humans shift from "round-by-round guidance" to "issue the task once, wait for results"

L3→L4 Bottleneck: Task Decomposition and Coordination

• Metric: Ability to split complex requirements into parallelizable subtasks, and information-sync efficiency between sub-agents
• Status: Devin can plan multi-step tasks but coordinates inefficiently; 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

L4→L5 Bottleneck: System Design Capability

• 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 to L5
• Breakthrough signal: When AI proactively says, "This module's code quality is degrading—I suggest refactoring, and here's an auto-generated refactor plan"

---

4. Who Is Attempting to "Jump Layers"

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

| Product | Current Layer | Jump Target | Strategy | Risk | |---------|--------------|-------------|----------|------| | Cursor | L2 | → L3 | Composer mode (8 parallel agents) | Parallel-agent coordination logic is still human-designed, not truly autonomous | | Claude Code | L3 | → L4 | Multi-file editing and tool calls | 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 | Heavily dependent on internal infrastructure; unclear generalization path |

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

---

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

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 be only a "transition path." The true endpoint is not "AI producing better code," but "AI directly generating runnable systems from intent, with code as an invisible intermediate artifact."

If this blind spot is broken, the five-layer model becomes a historical relic—just as we no longer describe the high-speed rail era using "horse carriage speed tiers."

---

6. Predictions: Where the Next Breakthrough Lies

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

1. "Trust infrastructure" for 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 blast radius")
• 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" for L4

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. "Intent compiler" for L5

Harness Engineering's ultimate goal is not making AI write more code, but making 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 actually realizes the intent)
• Intent version management (how systems gracefully evolve when intent changes)

---

7. Conclusion

The five-layer model is not truth—it is a thinking tool. Its value:

1. Helps you locate: Which layer is your tool on? What problem does it solve? 2. Helps you choose: If you need L3 capability, Cursor's L2+ layer-jump attempt may not be stable enough; if you need L4, Devin is more suitable than Claude Code. 3. Helps you predict: When someone says "AI will replace programmers," you can ask, "At which layer does that replacement happen?" The answer differs completely between L1 and L5.

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 floor, but one thing remains constant—

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

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

---

References

• 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