Skills Are the New Code

The arc

Venkat Peri's "From Routers to Reasoning" (Advisor360) presents a compelling framework for how agent architectures have evolved over the last three years. He identifies four distinct phases, each one a response to the failure mode of the previous. We want to credit that framing here, extend it, and explain why we think the fifth phase — skills — is the one that actually changes the game.

Phase 1: Monolithic prompts (2023). One giant system prompt. Every instruction, every guardrail, every piece of context crammed into a single string. It worked for demos. It broke in production. The failure mode was brittleness — change one thing and five other behaviors shift unpredictably.

Phase 2: Router architectures (2023–24). Split the monolith. A classifier routes queries to specialized prompt chains. Better modularity, but the routing logic itself became a maintenance nightmare. Every new capability required updating the router, and edge cases between routes multiplied.

Phase 3: Supervisory multi-agent (2024). Let an LLM be the router. A supervisor agent delegates to specialist agents. More flexible, but complexity exploded. Debugging a failure across three agents is harder than debugging one prompt. Context got lost between handoffs. Costs multiplied.

Phase 4: Deep reasoning agents (2024–25). Instead of more agents, make one agent smarter. Longer context windows, better chain-of-thought, tool use built into the model. This works — until you need the agent to follow YOUR process, not the model's default reasoning.

Peri identifies a fifth phase: skills. We agree — this is the phase that matters. Not because it makes the model smarter, but because it changes who can define agent behavior and how that behavior gets packaged, shared, and maintained.

The parallel to programming languages

The agent architecture evolution isn't novel. It mirrors a pattern we've seen before in programming itself. Each generation solved the previous one's pain point, and the winning move was always the same: raise the abstraction level.

We're at the Rails moment. The shift from "build everything from scratch" to "configure what you need" changes who can participate. Rails didn't make web development less powerful. It made it accessible to a thousand times more people. When a domain expert can author a skill in markdown instead of orchestrating agents in Python, the same democratization happens for AI.

What makes skills different from prompts

Skills look like prompts. They're text that tells an LLM how to behave. However, four distinct properties set them apart in practice.

The override model

Skills get interesting when you combine community best practices with your organization's specifics. The override model makes this clean: install a marketplace skill, then layer your customizations on top.

---
import: deal-triage
---
# Acme Sales Process

Our sales cycle is 45 days for mid-market, 90 for enterprise.

## Staleness thresholds by stage
- Prospecting: 7 days
- Qualification: 10 days
- Needs Analysis: 14 days
- Proposal: 14 days
- Negotiation: 21 days

## Enterprise exceptions
- All thresholds get 2x multiplier
- Decision maker must be identified by Proposal stage
- Flag any enterprise deal in Proposal without a
  contact with Role = "Decision Maker"

You inherit the community's best practices — the general structure of deal triage, the framework for identifying stale deals, the logic for escalation. You add your specifics: your cycle lengths, your stage definitions, your exceptions. When the community skill updates with better methodology, you get the improvements. Your overrides stay.

The marketplace implication

If skills are portable, version-controlled, and composable — they're shareable. A SOC team that writes a sharp threat triage skill can publish it. A sales team that perfects deal qualification can share it across the org. A consulting firm that codifies their methodology can distribute it to clients. This is the npm/PyPI moment for agent behavior.

We're not just versioning code anymore. We're versioning institutional knowledge. The skill file that encodes "how Acme handles enterprise deal qualification" is a durable artifact that captures years of hard-won experience in a format that both humans and agents can consume. That's never existed before.

What this means for 2027

Reasoning models will keep improving. Context windows will keep growing. New protocols will emerge and stabilize. None of this changes the fundamental problem: the model doesn't know your business. It doesn't know your process. It doesn't know what "good" looks like in your specific context.

The organizations that are documenting their workflows as skills TODAY are building a durable asset. Not because the current agent platforms will last forever — they won't. But because the methodology itself is portable. A markdown file that encodes your deal triage process works with Claude today and whatever model ships in 2028. It works with Amodal today and whatever runtime wins in three years.

The assembly-to-Rails arc took decades. The prompt-to-skills arc is happening in three years. The lesson is the same: the teams that move to higher abstractions first don't just move faster. They build assets that compound. Every skill written today is methodology captured, shareable, and ready for the next generation of reasoning — whatever form it takes.