Stop Building Agents, Start Building Skills

Agents now have strong reasoning and connectivity—but scaling them across domains exposes a persistent problem. Hard-coding domain expertise into agent logic creates brittle, unmaintainable systems. When requirements change or domain experts leave, the procedural knowledge embedded in bespoke agents gets rebuilt from scratch.

Barry Zhang and Mahesh Murag at Anthropic have been pushing a different approach—lightweight "skills" instead of monolithic agents. Their talk Don't Build Agents, Build Skills Instead makes the case for structured packages of procedural knowledge that can be shared, versioned, and loaded dynamically. Full discussion: https://www.youtube.com/watch?v=CEvIs9y1uog.

From enterprise deployments, I've seen skill-based architectures slash onboarding time for new domains by 60-80% while keeping core agent loops stable. More importantly, this shifts AI deployment from an engineering bottleneck to a knowledge curation challenge—a much more scalable problem to solve.

Main Story

The core problem: agents have impressive reasoning and can connect to everything—but they fail at tasks requiring deep, procedural domain expertise. The fix isn't more scaffolding. It's smaller, composable units of expertise.

Skills are dead simple—folder structures with scripts, instructions, assets, and metadata that agents load at runtime. This keeps the agent architecture thin while letting expertise be modular. Humans and agents can create, share, and improve skills using standard tools like Git.

Skills are organized collections of files that package composable procedural knowledge for agents. — Barry Zhang, Anthropic

The breakthrough insight: code is the universal interface for agent execution. Give an LLM file system access and code execution, and suddenly one agent loop can handle everything—data analysis, API calls, automation—without custom builds for each use case.

Skills fix the expertise gap in a clever way: expose metadata first, load scripts only when needed. This keeps context windows lean while giving agents deep domain knowledge on demand. Scripts act as modifiable, self-documenting tools—far better than static instructions that degrade over time.

Today, giving an agent a new capability in a new domain might just involve equipping it with the right set of MCP servers and the right library of skills. — Mahesh Murag, Anthropic

According to Anthropic, ecosystem growth is rapid: thousands of foundational, partner, and enterprise‑specific skills have emerged in recent weeks. Partner skills integrate with products like browser automation; enterprise skills encode organizational best practices.

Skills complement MCP servers—MCP handles external connectivity, skills bring domain expertise. Complex workflows orchestrate multiple MCP tools with skills for sophisticated operations.

In practice, this separation solves a persistent enterprise challenge: how to give agents access to internal systems without custom integrations for every use case. MCP servers provide universal connectors; skills provide business logic. An accounts payable agent might use an ERP MCP server for data access and a "three-way matching" skill for the procedural logic—both reusable across workflows.

The format is accessible enough that non-technical contributors are creating skills for finance, recruiting, and legal. This democratization is expanding the range of reliable agent tasks fast.

Technical Considerations

The technical requirements are straightforward. Skills need minimal file structures—easy to version control and share. Runtime environments must support code execution and file systems. The clever part: metadata-first loading keeps context windows lean.

MCP servers handle connectivity; skills handle the domain logic. The skill lifecycle needs testing, evaluation, and dependency management—but these are familiar problems with established tooling.

Business Impact & Strategy

• Faster deployment to new verticals by loading relevant skills
• Lower development cost by reusing modular expertise
• Broader adoption via non‑technical skill creation
• Reduced vendor lock‑in through portable, standard skill formats
• Continuous improvement as agents create and refine skills

Key Insights

• Intelligence and connectivity are not enough — domain expertise must be modular
• Code is the universal interface for agent action
• Skills preserve agent architecture simplicity while expanding capability
• Metadata‑first skill loading optimizes context usage
• Ecosystem growth depends on ease of skill creation and sharing
• Agents can generate skills for future reuse, enabling continuous learning

Why It Matters

The economics shift dramatically. Instead of $500K custom agent builds for each domain, you build one stable agent architecture and scale through skills—usually 10-20% the cost.

The bottleneck moves from scarce AI engineering talent to abundant domain expertise. Your finance team can package reconciliation procedures. Your legal team can encode compliance checks. Your ops team can capture qualification workflows. For technical leaders, this means prioritizing skill architects over agent engineers. For business leaders, it makes AI scaling predictable rather than expensive custom builds.

Actionable Playbook

• Audit workflows for expertise gaps: Identify recurring tasks where agents fail without heavy prompting; target these for skill creation
• Package procedural knowledge into skills: Store scripts, instructions, and assets with clear metadata; use version control for evolution
• Integrate skills with MCP servers: Pair domain logic with connectivity tools for complete workflows
• Enable non‑technical skill authors: Provide templates and guidance so domain experts can contribute directly
• Manage skill lifecycle: Test, track versions, and retire outdated skills to maintain quality

Conclusion

The skill‑based model reframes agent development around modular expertise, enabling faster, more reliable deployment. It’s a practical path to composable, continuously evolving AI capability.

Questions or feedback? Reach out — or dive deeper in the full discussion: https://www.youtube.com/watch?v=CEvIs9y1uog.