From Code Reuse to Vertical Intelligence: The New Architecture of Software
For 40 years, software architecture followed a principle called DRY: Don't Repeat Yourself. The goal was to write code once, reuse it everywhere. Libraries, frameworks, microservices—all built on the logic of code reuse.
This logic breaks down in the AI era.
Why Code Reuse Mattered (And Doesn't Anymore)
In the traditional era, code reuse was expensive to maintain. If your payment library had a bug, you had to fix it once, and every application benefited. This incentivized heavy upfront investment in reusable code.
In the AI era, code is disposable. A subagent can generate 10,000 lines of specialized code in ten seconds. Maintaining that code across multiple applications is expensive. Generating fresh code for each application is free.
The new principle is: Reuse intelligence, not code.
The Five Components of a Reusable Subagent
A super orchestrator relies on five components that are reusable across applications:
1. System Prompt (Persona + Scope)
This is the intelligence layer. A system prompt defines who the subagent is, what it knows, and what its constraints are.
Example for a financial analyst subagent:
- Who: "You are a senior portfolio manager with 20 years of experience in equities."
- What you know: "You understand macroeconomics, sector rotation, SEC filings, earnings models, risk management."
- Constraints: "You only recommend trades within the fund's risk limits ($5M max position, 20% max sector allocation)."
This intelligence is reusable. A solo developer writes this once, then deploys it across 100 fund management firms. Each firm gets the benefit of 20 years of simulated experience without paying for a human expert.
2. Horizontal Skills (Infrastructure)
Docker, Kubernetes, cloud APIs, authentication, monitoring. These are generic and reusable across all subagents.
3. Vertical Skills (Domain Expertise)
A finance subagent needs Bloomberg API knowledge, portfolio models, risk models. A healthcare subagent needs ICD-10 codes, FHIR standards, clinical literature. These are not reusable across domains, but are absolutely reusable within a domain.
A healthcare subagent's vertical skills include:
- Reading HL7 messages from hospital systems
- Cross-referencing clinical guidelines from Cochrane
- Understanding insurance coverage rules (CPT codes, approval workflows)
- Interpreting lab results and imaging reports
4. MCP Horizontal Connections (Dev Tools)
MCP stands for Model Context Protocol, the standard for connecting AI agents to tools. Horizontal MCPs connect to generic tools: GitHub, Docker registries, cloud platforms, CI/CD pipelines.
A subagent using MCP can read code from repositories, deploy containerized code to Kubernetes, trigger CI/CD pipelines, and monitor application health.
5. MCP Vertical Connections (Industry APIs)
This is where the defensibility lives. A finance subagent connects to Bloomberg API, real-time trading feeds, SEC EDGAR database. A healthcare subagent connects to hospital EHR systems (Epic, Cerner), drug databases (DrugBank), clinical literature (PubMed).
These integrations are not reusable across industries, but they're the moat. A solo developer who builds tight integrations with Epic Systems (used by 55% of U.S. hospitals) creates defensibility that competitors must rebuild from scratch.
Traditional Code Reuse vs. Vertical Intelligence Reuse
| Dimension | Traditional Code Reuse | Vertical Intelligence Reuse |
|---|---|---|
| Unit of Reuse | Libraries, APIs | System prompts, skill definitions, MCP connections |
| Lifetime | Long-lived (used for years) | Disposable (regenerated per application) |
| Maintenance | Centralized (one library, many users) | Distributed (each application owns its copy) |
| Scalability | Limited (library updates risk breaking changes) | Unlimited (new applications get fresh code) |
| Value Source | Code logic | Domain expertise and integrations |
A Concrete Example: Accounting Library vs. Accounting Subagent
Traditional approach: You build an accounting library with Chart of Accounts, General Ledger, Tax reporting. You maintain it across five accounting software products. Every time tax code changes, you update the library once. Every app benefits. But the library is complex because it supports every feature of every app.
AI-driven approach: You build an accounting subagent with:
- System prompt defining an expert accountant persona
- Knowledge base of current tax code (updated monthly via MCP)
- Integrations with QuickBooks, Xero, Freshbooks, Wave (all major accounting software)
- Vertical skills: GAAP standards, tax schedules, audit workflows
When you want to serve a new customer, you don't reuse code. You generate new code tailored to that customer's workflows. But you reuse the intelligence—the system prompt, the tax knowledge, the integrations.
The code is disposable. The intelligence is permanent. The value per developer stays high because you focus on domain expertise and integrations, not code maintenance.
Now you understand the architecture of reusable intelligence. The next insight is how to actually enter a vertical market and execute this strategy. That's where the Piggyback Protocol Pivot comes in.
Try With AI
Use your AI companion tool set up (e.g., ChatGPT web, Claude Code, Gemini CLI), you may use that instead—the prompts are the same.
Prompt 1: Grasp Intelligence vs. Code Reuse
The lesson says 'reuse intelligence, not code.' I'm struggling to grasp this. Explain the difference using a concrete example from everyday life (NOT software). Then apply it to a simple software scenario I can understand—maybe a calculator app or a todo list. What would 'reusing intelligence' look like vs 'reusing code'?
Expected outcome: Crystal-clear understanding of "reusing intelligence" using non-technical analogies.
Prompt 2: Deep Dive One Component
The lesson lists five components of a reusable subagent: (1) system prompt, (2) horizontal skills, (3) vertical skills, (4) horizontal MCPs, (5) vertical MCPs. Pick ONE component and explain it in depth. Why does this component matter? Give me a real example from [healthcare / finance / education—pick one].
Expected outcome: Deep dive into at least ONE component of a subagent (with real examples).
Prompt 3: Build A Subagent Roadmap
I'm confused by the accounting example at the end. Walk me through it step-by-step: If I wanted to build an 'accounting subagent' for small businesses, what would I actually build FIRST? What would I build SECOND? What would I build THIRD? Give me a 3-step roadmap that a beginner could follow.
Expected outcome: Step-by-step roadmap for building your first subagent (not overwhelming).
Prompt 4: Understand Disposable Code Economics
The lesson says 'code is disposable, intelligence is permanent.' This feels wasteful—why would I throw away code I just wrote? Help me understand: In what scenarios does DISPOSABLE code actually save time and money compared to REUSABLE code? Give me a practical decision framework.
Expected outcome: Decision framework for when to reuse code vs. regenerate it.