Andrej Karpathy describes the shift from code to prompts as a programming paradigm. Sounds like a backend concern — but it has massive consequences for anyone designing interfaces. Autonomy sliders, a third consumer class, and the most honest reality check on vibe coding yet.
Karpathy’s core thesis: software is moving through three paradigms — Code (1.0), Weights (2.0, neural networks), Prompts (3.0, natural language). Software 3.0 is eating 1.0 and 2.0. What sounds like an architectural shift at first has direct interface consequences: when the programming paradigm changes, interaction patterns change with it. A product whose logic is specified in natural language requires different surfaces than one whose logic lives in code. The question is no longer just “What does the UI look like?” but “How does the user communicate with a runtime that understands language?“
The strongest design pattern of the talk: Autonomy Sliders. Karpathy’s analogy is the Iron Man suit — AI should provide both augmentation and autonomy, contextually adjustable. The examples are concrete: Cursor scales from tab completion (minimal) through cmd+K (inline) to cmd+L (chat) to cmd+I (agent). Perplexity from search to research to deep research. Tesla Autopilot from Level 1 to 4.
The principle: Delegation is not a switch, it’s a dial. Users need the ability to adjust automation levels based on context. For interface designers, this means every AI interaction needs a model for gradually adjustable control — not just “on” or “off.”
Until now, there were two types of interface consumers: Humans (GUIs) and Computers (APIs). Karpathy describes a third class: Agents — human-like behavior, computer-like execution. This is not a theoretical construct. Agents need their own interfaces because they work optimally with neither GUIs nor traditional APIs. HTML is poorly parseable for LLMs. Formats like llms.txt and tools like Gitingest or DeepWiki are early responses to a new design problem: structuring information so that agents can consume it efficiently.
For product designers, the task shifts: not just “What does this look like for the user?” but additionally “How does an agent read this?“
LLMs exhibit an unintuitive capability distribution — they solve complex mathematical proofs but fail at determining whether 9.11 is greater than 9.9. Karpathy calls this “Jagged Intelligence.” Unlike human development, where capabilities grow in correlated fashion, LLM capabilities are unpredictably distributed.
This is a fundamental interface problem: Trust must be calibrated contextually. A user who watches the AI brilliantly solve a demanding task reasonably expects it to handle simpler tasks too. But it doesn’t, reliably. Trust patterns — visual and interactive signals that help users assess AI reliability — are becoming a central UX challenge.
“Demo is works.any(), product is works.all().” Karpathy’s sharpest statement. Backed by the Waymo anecdote: in 2014, the prototype worked with zero interventions — yet it took 10+ years to reach production readiness.
For interface designers, this is a corrective: Impressive AI demos don’t prove product readiness. The design must consciously bridge the gap between “sometimes works brilliantly” and “always works reliably” — through fallbacks, verification loops, and transparent uncertainty communication.
Karpathy acknowledges that initial AI speedups in development vanish after local setup. Web development in 2025 is “a disjoint mess of services designed for webdev experts to keep jobs, not accessible to AI.” Documentation quality determines whether AI agents can work with a tool or not.
For the interface and tooling world, this means: Agent-friendliness is becoming a quality criterion. Products whose documentation and interfaces are optimized for AI consumption will be preferred by vibe coders and agents. Ignoring this excludes a growing user class.
01 Autonomy Sliders in Practice: What would an autonomy slider pattern look like in a govtech context where decision transparency and traceability are mandatory? Is gradually adjustable autonomy compatible with public sector requirements?
02 Agent-first Design: If agents become the third consumer class — what does that concretely mean for our design systems? Do we need parallel interface layers (GUI + agent-optimized), or will formats converge?
03 Trust Patterns for Jagged Intelligence: How do you design trust in a system whose capabilities are unpredictably distributed? Are there patterns beyond confidence scores and disclaimers?
04 Demo-Product Gap as Design Task: If the gap between demo and product is larger for AI systems than for traditional software — what role does interface design play in bridging it? Is this a UX task or an architecture task?
05 Agent-Friendliness as Quality Criterion: Should we introduce “agent readiness” as a quality criterion for the documentation and interfaces of our own products?
Software 3.0 Karpathy’s term for the third software paradigm: natural language as programming language. Prompts replace code (1.0) and trained weights (2.0) as the primary programming interface.
Autonomy Slider Design pattern where users can contextually control the automation level of an AI interaction — from minimal assistance to full delegation.
Jagged Intelligence Phenomenon where LLMs exhibit unintuitive capability distributions: brilliant at complex tasks, unreliable at seemingly simple ones. Contrasts with human competence development, where capabilities grow in correlated fashion.
Agents (as Consumer Class) Software systems that act autonomously, navigate via LLM steering, and execute tasks. Differ from human users (GUIs) and traditional computer programs (APIs) through human-like behavior at computer-like execution speed.
Context Builder Tools like Gitingest or DeepWiki that prepare information for efficient LLM and agent processing. Address the problem that existing web formats (HTML) are poorly suited for AI consumption.
Weiterführende Betrachtung auf Panoptia Labs