软件 3.0

Software is no longer just eating the world, increasingly it's eating itself. The 21st century has seen the relentless process of industries being digitized and disrupted by software-driven solutions. In a recent talk, Andrej Karpathy offers a compelling framework for how this evolution can be conceptualized in three distinct stages: Software 1.0, Software 2.0, and the nascent Software 3.0. This progression marks a fundamental shift from programming with explicit instructions to programming by specifying desired outcomes, a trajectory that is redefining what it means to create and what it means to be a developer.

软件不再只是"吞噬世界"，它正越来越多地"吞噬自己"。21 世纪见证了各行各业被软件驱动的方案持续数字化、被颠覆的过程。在最近的一次演讲中，Andrej Karpathy 提供了一个引人注目的框架，把这种演变概念化为三个清晰的阶段：软件 1.0、软件 2.0，以及初露锋芒的软件 3.0。这一进程标志着从"用显式指令编程"到"通过描述期望结果来编程"的根本性转变——这条轨迹正在重新定义"创造"意味着什么，"做一名开发者"又意味着什么。

软件 1.0 / Software 1.0

Software 1.0 is the traditional world of programming. Human engineers write explicit instructions in code—algorithms, data structures, and logic painstakingly crafted to meet requirements. Every behavior is designed, debugged, and maintained by people. This approach, while the powerhouse of the modern world, is limited by the complexity that humans can manage and the speed at which they can operate.

软件 1.0 是传统的编程世界。人类工程师在代码中写下显式的指令——算法、数据结构、逻辑，都是为了满足需求而精心雕琢出来的。每一种行为都由人来设计、调试和维护。这种做法虽然是驱动现代世界的主力，但它受到"人所能驾驭的复杂度"和"人所能运作的速度"的限制。

Characteristics / 特征

• Explicit, human-written code
• Predictable, interpretable logic
• Scaling limited by human effort

• 显式的、人手写出的代码
• 可预测、可解释的逻辑
• 规模受限于人力

Despite its limitations, Software 1.0 underpins the vast majority of today's digital infrastructure.

尽管有这些局限，软件 1.0 仍然是当今绝大多数数字基础设施的根基。

Even in Software 1.0, we see the first signs of software consuming itself:

即便在软件 1.0 时代，我们已经能看到软件"吞噬自身"的最初迹象：

• Compilers eating assembly code and producing machine code
• High-level languages eating the complexity of memory management
• Frameworks eating boilerplate code and common patterns
• APIs eating the need to understand underlying system complexity

• 编译器吞噬汇编代码，产出机器码
• 高级语言吞噬了内存管理的复杂性
• 框架吞噬了样板代码和常见模式
• API 吞噬了理解底层系统复杂性的必要

软件 2.0 / Software 2.0

Software 2.0 marks a paradigm shift. Instead of hand-writing rules, developers specify objectives and provide data. The rules—often in the form of neural network weights—are learned by the computer. This is the era of machine learning, where algorithms like deep learning find patterns and solutions inaccessible to human-crafted code.

软件 2.0 标志着一次范式转移。开发者不再手写规则，而是指定目标并提供数据。规则——通常以神经网络权重的形式——由计算机自己学出来。这就是机器学习的时代，深度学习这类算法能找到人类手写代码所触及不到的模式和解法。

Characteristics / 特征

• Models trained on data, not written by hand
• Emergent, often opaque logic
• Scaling with data and compute, not just humans

• 模型由数据训练而成，而非手写
• 涌现的、常常不透明的逻辑
• 规模随数据和算力增长，而不仅仅靠人

Software 2.0 enables breakthroughs in fields like vision, language, and robotics. But it also introduces meta-software: instead of writing the solution, engineers write the software that creates the solution. This is software eating software—the first layer of recursion.

软件 2.0 在视觉、语言、机器人等领域带来了突破。但它也引入了"元软件"：工程师不再写解法本身，而是写"用来生成解法的软件"。这就是软件吞噬软件——递归的第一层。

This transition represents the first major "eating" event:

这次转变代表了第一次重大的"吞噬"事件：

What Gets Consumed / 被吞噬的对象

• Feature Engineering → Automatic feature learning
• Rule-Based Systems → Pattern recognition from data
• Expert Systems → End-to-end learning
• Traditional Computer Vision → Convolutional neural networks
• Statistical NLP → Transformer architectures

• 特征工程 → 自动特征学习
• 基于规则的系统 → 从数据中识别模式
• 专家系统 → 端到端学习
• 传统计算机视觉 → 卷积神经网络
• 统计自然语言处理 → Transformer 架构

The Transformation Process / 转变过程

• Identification: Find domains where Software 1.0 struggles with complexity
• Data Collection: Gather massive datasets representing desired behavior
• Architecture Design: Create neural network structures
• Training: Let optimization find the solution
• Deployment: Replace traditional code with neural networks

• 识别：找出软件 1.0 在复杂度上力不从心的领域
• 数据收集：聚集代表期望行为的大规模数据集
• 架构设计：创建神经网络结构
• 训练：让优化算法找出解法
• 部署：用神经网络替换传统代码

软件 3.0 / Software 3.0

Software 3.0 is the latest and perhaps most radical evolution. Here, large language models (LLMs) and generative AI can produce code, design new models, and even orchestrate entire systems with minimal human intervention. The boundary between code, data, and intention blurs. The software that writes software can now write itself or create new, unforeseen forms of software.

软件 3.0 是最新的、或许也是最激进的演变。在这一阶段，大语言模型（LLM）和生成式 AI 可以编写代码、设计新模型，甚至能在极少人工干预的情况下编排整套系统。代码、数据与意图之间的边界变得模糊。"编写软件的软件"现在可以编写自身，或创造出全新的、此前无法预见的软件形态。

Characteristics / 特征

• Generative models (e.g., GPT-4, Claude, Gemini) capable of code synthesis and system design
• Self-improving loops: AI models optimizing, retraining, or evolving themselves
• Human engineers become curators, supervisors, or collaborators rather than sole creators

• 生成式模型（如 GPT-4、Claude、Gemini）具备代码合成与系统设计能力
• 自我改进的闭环：AI 模型优化、重训、甚至演化自身
• 人类工程师从唯一的创造者，转变为策展人、监督者或协作者

With Software 3.0, we witness software eating the software that eats software. LLMs can generate training data, architect new learning algorithms, and recursively improve both themselves and the systems they build. The feedback loop accelerates, and the locus of creativity shifts from explicit design to collaborative emergence.

在软件 3.0 中，我们见证的是"软件吞噬那个吞噬软件的软件"。LLM 能够生成训练数据、设计新的学习算法，并递归地改进自身以及它们所构建的系统。反馈闭环在加速，创造力的重心从"显式设计"转向"协作式涌现"。

The most recent "eating" event is already underway:

最近一次"吞噬"事件已经在发生：

What's Being Consumed / 正在被吞噬的对象

• Manual Model Architecture Design → Neural Architecture Search
• Hyperparameter Tuning → Automated optimization
• Feature Engineering → Foundation models with emergent capabilities
• Task-Specific Training → Few-shot and zero-shot learning
• Model Deployment → Automated MLOps pipelines

• 手工模型架构设计 → 神经架构搜索（NAS）
• 超参数调优 → 自动化优化
• 特征工程 → 具备涌现能力的基础模型
• 针对特定任务的训练 → 少样本与零样本学习
• 模型部署 → 自动化 MLOps 流水线

三层协同：一个客服系统的实例

To illustrate how Software 1.0, 2.0, and 3.0 approaches work together in practice, let's examine a contemporary AI-powered customer service platform—a representative example of how modern AI products are architected.

为了说明软件 1.0、2.0、3.0 三种方法在实践中如何协同，我们来看一个当代的 AI 客服平台——它是现代 AI 产品架构方式的典型样本。

Consider a sophisticated customer service system that can handle complex inquiries across multiple channels. This system demonstrates the strategic deployment of all three software paradigms:

设想一套能在多个渠道处理复杂咨询的精密客服系统。这套系统展示了对三种软件范式的战略性部署：

Software 1.0 Layer: The Reliable Foundation
软件 1.0 层：可靠的根基

🔧 Traditional Components:

🔧 传统组件：

• Database management (customer records, transaction history)
• Authentication and security systems
• API integrations with CRM, billing, and inventory systems
• Load balancing and monitoring infrastructure
• Compliance and audit logging
• Escalation workflows and routing logic — These components require deterministic, predictable behavior. When a customer's payment fails, the system must reliably update their account status—there's no room for probabilistic outcomes in financial transactions.

• 数据库管理（客户档案、交易历史）
• 认证与安全系统
• 与 CRM、计费、库存系统的 API 集成
• 负载均衡与监控基础设施
• 合规与审计日志
• 升级工单的工作流与路由逻辑 —— 这些组件需要确定性、可预测的行为。当客户的支付失败时，系统必须可靠地更新其账户状态——在金融交易中没有"概率性结果"的容身之地。

Software 2.0 Layer: The Intelligence Engine
软件 2.0 层：智能引擎

🧠 Learned Components:

🧠 学习型组件：

• Natural Language Understanding (intent classification, entity extraction)
• Sentiment analysis for conversation tone
• Document retrieval and semantic search
• Language translation for multilingual support
• Voice-to-text and text-to-voice conversion
• Fraud detection based on conversation patterns — These capabilities emerge from training on massive datasets of customer interactions, support tickets, and domain-specific knowledge. The system learns to recognize when someone is asking about a refund versus a technical issue without explicit programming for every possible variation.

• 自然语言理解（意图分类、实体抽取）
• 对话语气的情感分析
• 文档检索与语义搜索
• 多语言支持的语言翻译
• 语音转文字与文字转语音
• 基于对话模式的欺诈检测 —— 这些能力源自在海量客户交互、工单、领域知识数据集上的训练。系统学会辨别某人是在问退款还是在反馈技术问题，而不必为每一种可能的措辞变体都写明代码。

Software 3.0 Layer: The Adaptive Interface
软件 3.0 层：自适应界面

🚀 Generative Components:

🚀 生成式组件：

• Dynamic response generation tailored to context and customer history
• Real-time code generation for custom integrations
• Automated creation of new training scenarios
• Self-improving conversation flows based on success metrics
• Personalized interaction strategies that evolve per customer
• Meta-learning cross-customer patterns to improve overall performance — This layer can generate novel solutions for unprecedented situations, create personalized responses that have never been written before, and even improve its own training processes.

• 根据上下文与客户历史量身定制的动态回复生成
• 为定制化集成实时生成代码
• 自动创建新的训练场景
• 基于成功指标自我改进的对话流程
• 针对每个客户不断演化的个性化交互策略
• 元学习跨客户的共性模式以提升整体表现 —— 这一层能为前所未有的情境生成新颖解法，创造出从未被写过的个性化回复，甚至改进自身的训练流程。

The magic happens in how these layers interact:

真正的魔力在于这三层如何互动：

Customer Contact / 客户触达

Customer Contact: A user messages "I'm really frustrated! My order was supposed to arrive yesterday for my daughter's birthday party today, and it's still not here!"

客户触达：一位用户发来消息——"我真的快崩溃了！我的订单昨天就该到了，今天是我女儿的生日派对，结果到现在还没送达！"

Software 1.0 handles the infrastructure:

软件 1.0 处理基础设施：

• Routes the message through security validation
• Looks up order status in the database
• Checks shipping carrier APIs for tracking information

• 把消息路由经过安全校验
• 在数据库中查询订单状态
• 调用承运商 API 核对物流信息

Software 2.0 provides intelligence:

软件 2.0 提供智能：

• Detects high emotional sentiment (frustration, urgency)
• Identifies entities (order, delivery date, special occasion)
• Classifies intent (delivery inquiry + complaint)
• Retrieves relevant policy documents

• 检测出强烈的情感（沮丧、紧迫）
• 识别实体（订单、送达日期、特殊场合）
• 分类意图（物流咨询 + 投诉）
• 检索相关的政策文档

Software 3.0 generates the response:

软件 3.0 生成回复：

• Creates a personalized, empathetic response acknowledging the birthday party context
• Generates specific compensation options based on the situation
• Adapts communication style to match the customer's emotional state
• Learns from this interaction to improve future birthday-related delivery issues

• 生成一封个性化、有同理心的回复，明确提到生日派对的情境
• 根据具体情况生成具体的补偿方案
• 调整沟通风格以匹配客户的情绪状态
• 从这次交互中学习，以改进未来与生日相关的配送问题

This hybrid approach provides several advantages:

这种混合方式带来几项优势：

• Reliability Where It Matters: Financial transactions and data integrity use Software 1.0's predictable logic.
• Intelligence Where It Adds Value: Understanding customer intent and retrieving relevant information leverages Software 2.0's pattern recognition.
• Creativity Where It Differentiates: Generating personalized, contextually appropriate responses uses Software 3.0's generative capabilities.

• 在关键处求可靠：金融交易与数据完整性使用软件 1.0 的可预测逻辑。
• 在增值处求智能：理解客户意图、检索相关信息，借助的是软件 2.0 的模式识别。
• 在差异化处求创造：生成个性化、贴合情境的回复，用的是软件 3.0 的生成能力。

递归吞噬的深远影响

This recursive "software eating software eating software" dynamic has profound implications:

这种"软件吞噬那个吞噬软件的软件"的递归动态，有着深远的影响：

• Acceleration: Each layer amplifies the speed and scope of innovation. What once took months or years to code can now be generated, tested, and deployed in hours.
• Abstraction: Human programmers move up the stack, focusing on higher-order objectives, ethics, and supervision.
• Opacity and Risk: Each new layer introduces more abstraction and less interpretability. Understanding and controlling these systems becomes more challenging.
• Creativity and Collaboration: The role of the engineer shifts from direct author to orchestrator, collaborator, or even prompt engineer—guiding powerful systems toward desirable outcomes.

• 加速：每一层都放大创新的速度与范围。曾经要花几个月甚至几年才能写出的代码，现在可以在几小时内生成、测试并部署。
• 抽象：人类程序员沿技术栈向上攀升，专注于更高阶的目标、伦理与监督。
• 不透明与风险：每新增一层都带来更多抽象、更少的可解释性。理解并控制这些系统变得越来越具挑战。
• 创造与协作：工程师的角色从"直接作者"转变为编排者、协作者，甚至是 prompt 工程师——引导强大的系统走向期望的结果。

This progression from 1.0 to 3.0 represents a relentless climb up the ladder of abstraction. We moved from telling the machine how to do something (Software 1.0), to showing it what to do through examples (Software 2.0), to now simply telling it what we want (Software 3.0). Each stage subsumes the previous one. A Software 3.0 system (an LLM) can generate Software 1.0 code or even the configuration for a Software 2.0 model. This is software eating software, a recursive loop where the tools of creation are themselves being created by the tools. The ultimate challenge will be to manage, verify, and steer these increasingly autonomous systems, ensuring that the software they write aligns with human intent and values, even as the process of its creation becomes ever more abstract.

从 1.0 到 3.0 的这一进程，代表着沿"抽象之梯"的无情攀升。我们从"告诉机器怎么做"（软件 1.0），走到"用例子给它看做什么"（软件 2.0），再到如今"直接告诉它我们想要什么"（软件 3.0）。每一阶段都把前一阶段囊括其中。一个软件 3.0 系统（一个 LLM）可以生成软件 1.0 的代码，甚至能为软件 2.0 的模型生成配置。这就是软件吞噬软件——一个递归闭环，创造工具本身正在被工具所创造。最终的挑战将在于：管理、验证并引导这些日益自主的系统，确保它们所写的软件与人类的意图和价值观相一致——哪怕其创造过程已变得愈发抽象。

Karpathy's framework reveals that we're not just witnessing technological progress—we're observing a fundamental phase transition in the nature of computation itself. Software isn't just eating the world; it's recursively consuming and transforming itself in an accelerating spiral of abstraction and capability.

Karpathy 的框架揭示出：我们见证的不仅是技术进步——我们正在观察计算本质本身的一场根本性相变。软件不只是吞噬世界；它正在一个不断加速的"抽象与能力"螺旋中，递归地吞噬并重塑自身。

The pattern is clear: each generation of software makes the previous generation's complexity invisible while enabling entirely new classes of problems to be solved. We're living through the transition from Software 2.0 to 3.0, and the implications extend far beyond technology into the very fabric of how we work, create, and understand our world.

规律很清晰：每一代软件都让上一代的复杂性变得"不可见"，同时又使全新一类问题变得可解。我们正身处从软件 2.0 到 3.0 的过渡之中，其影响远远超出技术范畴，深入到我们工作、创造和理解世界的肌理本身。

As we navigate this transition, the key insight from Karpathy's framework is that fighting these changes is futile—the eating will continue. Instead, we must learn to ride the wave, understanding each paradigm's strengths and limitations while preparing for the next inevitable transformation.

在我们穿越这场转变时，Karpathy 框架给出的关键洞见是：对抗这些变化是徒劳的——吞噬还会继续。相反，我们必须学会驾驭这股浪潮，理解每一种范式的长处与局限，同时为下一次不可避免的转变做好准备。

The future belongs to those who can dance between paradigms, leveraging the power of each generation while remaining adaptable enough to evolve with the next wave of software eating software eating software.

未来属于那些能在范式之间起舞的人——既能调用每一代软件的力量，又保持足够的适应性，去跟随下一波"软件吞噬那个吞噬软件的软件"的浪潮一同演化。

Editor's note: This article represents a curated conversation between models responding to identical prompts that attempts to preserve the strengths of each while still reading coherently. Software 3.0 is eating the layers below it, but as editors, creators and developers we are eating it as well.

编者按：本文呈现的是多个模型对相同提示的回应经编辑整合而成的一次"策展式对话"，旨在保留各自的优点同时保持整体可读。软件 3.0 正在吞噬它下面的各层，但作为编辑、创作者与开发者的我们，同样也在"吞噬"它。