Software was always an intermediate representation. When agents can execute intent directly, the code layer becomes optional. L6 is agents running processes, not writing programs.
Links: Planner-LM Composites (L5/L6 only deliver on problems whose domain supplies what a planner needs), Cyborg Model, Praxis — Agent Teams, Claude Opus 4.6 Research, Cognitive vs. Motor Skills, Karpathy LLM Wiki Convergence, Career
From The 5 Levels of AI Coding (Nate B Jones, 2026-02-18) — Transcript:
| Level | Name | Human role | AI role | Who reads code? |
|---|---|---|---|---|
| 0 | Spicy autocomplete | Writes code | Suggests next line | Human |
| 1 | Coding intern | Architects | Handles discrete tasks | Human reviews all |
| 2 | Junior developer | Reviews | Multi-file changes, navigates codebase | Human reads all |
| 3 | Developer as manager | Directs, approves/rejects PRs | Implements features | Human skims |
| 4 | Product manager | Writes spec, checks outcomes | Implements, tests | Human checks tests |
| 5 | Dark factory | Writes spec | Everything — spec in, software out | Nobody |
Key data points from the video:
90% of developers who think they’re AI-native are at L2. The bottleneck is not the tool — it’s the willingness to redesign workflows, org charts, and identity around AI as the executor.
The 5 levels progressively remove the human from code writing. Level 6 removes the code itself.
| Level | Artifact | Example |
|---|---|---|
| L5 | Software (agent-written) | “Write me inventory management software” → code → software manages inventory |
| L6 | No software — the agent IS the process | “Manage my inventory” → agent manages inventory directly |
Software was always an intermediate representation. Humans needed it because machines couldn’t understand intent. You wanted “track what’s in my warehouse and reorder when stock is low” — but machines needed that translated into loops, conditionals, database queries, API calls. The code was the translation layer between human intent and machine execution.
At L6, the agent understands the intent directly. The translation layer is optional. Sometimes you still want durable software (for performance, reliability, offline operation). But for many processes, the agent can just… do it.
In SimCity, you don’t write a zoning-management program. You click “zone residential here” and the system executes. In Factorio, you don’t write logistics code — you place a belt and the system routes items. The interface IS the execution layer. The code is invisible because it was never the point — the process was the point.
L6 extends this to real-world processes. The agent is the factory floor manager, the inventory clerk, the project coordinator — not the software that those people used to use.
L5 is “the prefrontal cortex writes detailed motor plans for the motor cortex to execute.” L6 is “the prefrontal cortex intends, and the system executes.”
That’s how actual brains work. You don’t write a motor program to reach for a cup — you intend to reach for the cup, and the motor system figures out the muscle activations. The conscious mind specifies WHAT, the subsystems handle HOW. The intermediate representation (motor plan) exists but is invisible to the conscious agent.
The vault itself documents the trajectory across just three months:
| Date | Snapshot | Level |
|---|---|---|
| Feb 2026 (Praxis, first vault entry) | Agents as Jira managers, autocompleting tasks. Bad automated fridge. Rakuten managing 50 devs with agent routing. Success requires human in the loop for grounding. | L2-L3 |
| Feb 2026 (this video) | StrongDM dark factory. 3 people, no Jira. Claude Code self-referential. “We threw out Jira.” | L5 |
| Apr 2026 (Karpathy convergence) | LLM wiki pattern — agents maintaining knowledge bases, not writing knowledge-base software. The vault’s skills execute processes directly (ingest, sync, heartbeat). | Proto-L6 |
| Apr 2026 (this page) | Prediction: L6 is next. Agents executing business processes, not writing software to execute them. | L6 (predicted) |
The pacing problem is real. Three months from “agents struggle with fridges” to “throw out Jira and run a dark factory.” Each vault review is a snapshot of where the frontier is, and each snapshot obsoletes the last.
Proto-L6 is already happening in narrow domains:
/vault-ingest doesn’t write ingestion software. It ingests. /vault-sync doesn’t write sync software. It syncs. The agent IS the process.What’s changing is the generality. These were narrow, brittle, pre-programmed. LLM-based agents can handle ambiguity, novel situations, and multi-step reasoning — which is what makes general L6 newly viable.
| Dimension | L5 (Dark factory) | L6 (Direct execution) |
|---|---|---|
| Output | Working software | Working outcomes |
| Durability | Persistent artifact (code, binaries) | Ephemeral — the agent acts, results persist as data/state changes |
| Specification | Detailed enough for code generation | Intent-level — “keep inventory above safety stock” |
| Failure mode | Buggy software | Wrong action (higher stakes, harder to undo) |
| Human role | Write specs, evaluate software | State intent, evaluate outcomes |
| Trust requirement | Trust the software (testable) | Trust the agent (requires grounding, judgment) |
The trust gap is the key barrier. L5 produces an artifact you can test. L6 produces actions you can only evaluate after the fact. This maps directly to the LLM grounding problem — the agent needs enough understanding of real-world consequences to act responsibly.
L6 doesn’t eliminate the need for humans at the edges. It moves the boundary. Three constraints surfaced during real-world coding work:
1. UI Convergence — When AI generates all code, UIs converge toward model defaults. Every Claude-generated app starts looking the same. Implementation is commoditized; the differentiator migrates to style and taste — the human judgment about what looks right, feels right, matches the brand. This is the Cyborg Model’s “quality/taste” function becoming the primary competitive edge at L5+.
2. Style as the New UX — When every L5 shop ships equivalent code quality, the competition shifts to aesthetics, feel, and identity. AI can generate unlimited variations; the human picks which one. “Taste” — previously a soft skill — becomes the hardest and most valuable capability in production software.
3. The Human Buffer at System Boundaries — Two directions:
The permanent insight: The buffer isn’t a temporary problem to be solved. It’s a permanent feature of the architecture. It has always existed — early computing was physical switches and manual wiring; then punch cards; then assembly; then high-level languages; then GUIs; then natural language; now intent. Each step pushed the boundary forward into territory that previously required humans.
But the boundary migrates both directions simultaneously:
The buffer doesn’t shrink monotonically. It oscillates. This is the opposing forces pattern applied to human-machine interaction. The cyborg model’s core claim: the boundary migrates to wherever the current friction is, but it never disappears — and pushing too hard in either direction generates counter-pressure.
The L5/L6 transition isn’t a spec you design up front. The boundary between rule-sufficient (L6-ready) and judgment-required (stays human) isn’t something you can articulate before watching real operations. Attempts to fix it at design time either leave gaps (cases rules didn’t anticipate) or overreach (forcing rules where context-dependent judgment was doing the work). The boundary has to be discovered through operation, which means a useful L5/L6 system treats the boundary itself as a first-class object — not as an implementation detail that freezes at launch.
Five design properties follow from that reframe:
A customer-service system tried to encode “who should be allowed to place manual stock orders” as rules on customer attributes (ranking, entitlement, OCR state, monthly counter). The design collapsed under edge cases accumulating faster than rules could cover them. The fix was to fall back to role-based authority (trained CSRs can, untrained can’t) and capture the decision reason in a structured dropdown. The rule-encoded future state isn’t gone — it’s deferred until the manual-order log generates enough signal to derive rules with empirical grounding. L5 operation is the data-collection phase for L6 rules.
L5 is often framed as a placeholder — “temporary state awaiting full automation.” That misframes what L5 is doing. L5 is the evidence-generating phase that earns L6 operation. The system produces two outputs: customer outcomes (visible, current) and decision-pattern data (invisible, compounds over time). A mature design treats the second output as a first-class deliverable, not a happy accident of having humans in the loop. That reframe changes what the system should measure, log, and expose — and it explains why systems that try to short-circuit the L5 phase by designing L6 rules up front tend to fail: they’re trying to encode knowledge they don’t yet have.