Welcoming the Era of (opens in new tab)

The tech industry is shifting from Software 1.0 (explicit logic) and 2.0 (neural networks) into Software 3.0, where natural language prompts and autonomous agents act as the primary programming interface. While Large Language Models (LLMs) are the engines of this era, they require a "Harness"—a structured environment of tools and protocols—to perform real-world tasks effectively. This evolution does not render traditional engineering obsolete; instead, it demonstrates that robust architectural principles like layered design and separation of powers are essential for building reliable AI agents.

The Evolution of Software 3.0

• Software 1.0 is defined by explicit "How" logic written in languages like Python or Java, while Software 2.0 focuses on weights and data in neural networks.
• Software 3.0, popularized by Andrej Karpathy, moves to "What" logic, where natural language prompts drive the execution.
• The "Harness" concept is critical: just as a horse needs a harness to be useful to a human, an LLM needs tools (CLI, API access, file systems) to move from a chatbot to a functional agent like Claude Code.

Mapping Agent Architecture to Traditional Layers

• Slash Commands as Controllers: Tools like /review or /refactor act as entry points for user requests, similar to REST controllers in Spring or Express.
• Sub-agents as the Service Layer: Sub-agents coordinate multiple skills and maintain independent context, mirroring how services orchestrate domain objects and repositories.
• Skills as Domain Components: Following the Single Responsibility Principle (SRP), individual skills should handle one clear task (e.g., "generating tests") to prevent logic bloat.
• MCP as Infrastructure/Adapters: The Model Context Protocol (MCP) functions like the Repository or Adapter pattern, abstracting external systems like databases and APIs from the core logic.
• CLAUDE.md as Configuration: Project-specific rules and tech stacks are stored in metadata files, acting as the package.json or pom.xml of the agent environment.

From Exceptions to Questions

• Traditional 1.0 software must have every branch of logic predefined; if an unknown state is reached, the system throws an exception or fails.
• Software 3.0 introduces Human-in-the-Loop (HITL), where "Exceptions" become "Questions," allowing the agent to ask for clarification on high-risk or ambiguous tasks.
• Effective agent design requires identifying when to act autonomously (reversible, low-risk tasks) versus when to delegate decisions to a human (deployments, deletions, or high-cost API calls).

Managing Constraints: Tokens and Complexity

• In Software 3.0, tokens represent the "memory" (RAM) of the system; large codebases can lead to "token explosion," causing context overflow or high costs.
• Deterministic logic should be moved to external scripts rather than being interpreted by the LLM every time to save tokens and ensure consistency.
• To avoid "Skill Explosion" (similar to Class Explosion), developers should use "Progressive Disclosure," providing the agent with a high-level entry point and only loading detailed task knowledge when specifically required.

Traditional software engineering expertise—specifically in cohesion, coupling, and abstraction—is the most valuable asset when transitioning to Software 3.0. By treating prompt engineering and agent orchestration with the same architectural rigor as 1.0 code, developers can build agents that are scalable, maintainable, and truly useful.