Entering the Era of Software 3.0

Software 1.0 was the era where humans wrote rules directly in Python, Java, or C++, and Software 2.0 was the stage where the weights of deep learning models took on the role of the program. Software 3.0 is described as the era where you instruct an LLM in natural language about "what" you want, and the prompt becomes the program.

However, LLMs cannot read files, call APIs, or access databases on their own. That's why a harness is needed. To use a horse analogy, just as equipment lets you actually harness a horse's power and speed, LLMs need tools and infrastructure connecting them to real-world work.

From this perspective, Claude Code can be seen as a harness for Claude. File system access, terminal execution, MCP, sub-agents, slash commands, Skills, and Hooks combine to turn an LLM from a mere generator into an agent that actually performs tasks.

This structure also resembles traditional layered architecture.

• A Slash command is like a controller, serving as the entry point for a user request.
• A Sub-agent is like a service layer, combining Skills to complete a task.
• Skills are domain-level components that follow SRP.
• MCP acts as the infrastructure/adapter layer connecting to databases, APIs, and the file system.
• CLAUDE.md holds project rules and build commands that rarely change, much like package.json or pom.xml.

As a result, the same anti-patterns seen in traditional software also appear in agent design. Representative examples include God skill, Spaghetti CLAUDE.md, tight coupling such as hardcoded direct calls, leaky abstraction where boundaries break down, and problems like circular calls. Code smells such as Feature Envy, Duplication, and Long Method also map directly onto Skills and Sub-agent design.

However, unlike a traditional service layer, an agent allows for HITL (Human-in-the-Loop). When a situation arises that wasn't predefined, the agent can pause and ask the user for a choice, and the user can pick between A or B. In other words, while traditional exception handling meant "error or default value," in agents it becomes "ask, then continue."

The key is when to ask and when to act. For hard-to-reverse operations like deletion, deployment, or external API calls, for tasks with multiple options where the correct answer is unclear, and for tasks with high cost or risk, it's better to ask. Conversely, for tasks that are safe, repeatable, and easy to reverse, it's better to execute immediately.

The transition from Software 1.0 to 3.0 doesn't render existing knowledge meaningless. Still needed are layer separation, single responsibility, abstraction, dependency management, interface design, testability, debugging strategy, code review, and incremental improvement. What must now be let go of, however, is "the habit of trying to explicitly specify all logic" and "the attitude of trying to predefine every edge case."

Instead, in the agent era, tokens become memory. The context window is working memory, and CLAUDE.md, Skills, conversation history, and MCP responses all accumulate within it. So to reduce token inefficiency, rather than having the prompt continually reinterpret rules, it's better to extract deterministic logic into reusable scripts.

Another pitfall is Skill explosion. Just as excessive SRP splitting causes classes to explode, over-fragmenting Skills only increases metadata and eats up context. Therefore, it's appropriate to keep SKILL.md as the entry point and separate detailed rules into references/, using progressive disclosure to load them only when needed.

In practice, a slash command like /setup illustrates this pattern well. The agent automatically detects the environment and asks only about ambiguous parts to finish the setup. In other words, the core of the Software 3.0 era isn't about using LLMs at a larger scale—it's about enabling LLMs to balance judgment and execution through proper layering and tooling.