FROM AGENTS TO SKILLS
STOP REBUILDING AGENTS FROM SCRATCH
Barry Zhang and Mahesh Murag argue that instead of building a new agent for every domain, we should build skills – modular, reusable blocks of procedural knowledge that any general agent can call when needed.
THE LIMITS OF MONOLITHIC AGENTS
POWERFUL, BUT NOT PRACTICAL ENOUGH
Early agents were domain specific, with custom scaffolding and tools for each use case. They could do impressive demos, but were hard to maintain, lacked consistent domain expertise, and did not scale well across many real world workflows.
CODE AS THE UNIVERSAL INTERFACE
CLAUDE CODE AS A GENERAL PURPOSE AGENT
Anthropic realized that code is a universal interface between models and the digital world. With Claude Code, the agent can run code to search, transform, and integrate data across systems, acting as a general purpose executor rather than a hard wired, domain specific bot.
THE MISSING PIECE: DOMAIN EXPERTISE
WHY GENERAL AGENTS ARE NOT ENOUGH
Even with code execution, agents often lack deep, repeatable domain expertise. Tasks like tax preparation, compliance checks, or complex research need procedural knowledge that is consistent, auditable, and shareable, not reinvented each time in a prompt.
WHAT IS AN AGENT SKILL
PROCEDURAL KNOWLEDGE IN A FOLDER
A skill is essentially an organized folder of files that encodes how to do something. It can contain scripts, prompts, instructions, templates, and configuration. Skills are simple, human readable, and agent readable, and can be versioned, shared, and reused like normal code projects.
SKILLS VS TRADITIONAL TOOLS
FROM STATIC APIS TO LIVING CODE
Traditional tools exposed to agents are often rigid or poorly documented. Skills, by contrast, use code that is self documenting, testable, and composable. They behave like small software components, making it easier to understand, edit, and scale the behavior of agents.
SKILLS AS COMPOSABLE BUILDING BLOCKS
MIX AND MATCH FOR NEW WORKFLOWS
Instead of one giant agent that knows everything, you assemble workflows by combining multiple skills. Each skill solves a narrow problem well, and the agent orchestrates them. This modularity lets teams grow capabilities without rewriting entire agents.
PROGRESSIVE DISCLOSURE OF SKILLS
METADATA FIRST, FULL CONTENT ON DEMAND
To avoid overloading the model context, skills are progressively disclosed. At first, the agent only sees metadata about available skills. When it decides a skill is relevant, the runtime loads that skill’s files and instructions at execution time, preserving context space.
SCALING TO HUNDREDS OF SKILLS
CONTEXT MANAGEMENT AS A DESIGN CONSTRAINT
Because only the needed skills are fully loaded, the system can maintain a large library – potentially hundreds or thousands of skills – without blowing up the context window. The agent loop selectively pulls in the exact procedures required for a given task.
FOUNDATIONAL SKILLS
GENERAL AND DOMAIN SPECIFIC PRIMITIVES
Foundational skills provide common capabilities like document editing, summarization, research workflows, and basic data analysis. Others encode domain specific patterns for areas such as scientific work, financial analysis, recruiting, or legal review.
THIRD PARTY SKILLS
VENDORS BRING THEIR OWN EXPERTISE
Partners can publish skills that integrate their own products. Examples include browser automation from Browserbase or in depth workspace research for Notion. This lets software companies expose powerful workflows to agents without forcing everyone to integrate directly with their APIs.
ENTERPRISE SKILLS
ENCODING HOW YOUR COMPANY ACTUALLY WORKS
Enterprises can build private skills that represent internal best practices – how to use internal tools, how to run specific processes, how to comply with policies. These skills capture institutional knowledge so agents behave like seasoned team members, not interns guessing from scratch.
AN ECOSYSTEM GROWING FAST
THOUSANDS OF SKILLS WITHIN WEEKS
Once the concept shipped, the ecosystem grew quickly. Within weeks, thousands of skills were created across different use cases. This indicates that skills are simple enough for many builders to adopt and flexible enough to represent a wide range of workflows.
SKILLS AND MCP SERVERS
CONNECTIVITY PLUS EXPERTISE
Anthropic’s MCP standard focuses on connecting models to external systems – databases, APIs, SaaS tools. Skills complement this by providing the procedural knowledge of how to use those connections. MCP is the wiring, skills are the playbooks for what to do with that wiring.
NON TECHNICAL USERS CAN BUILD SKILLS
FINANCE, RECRUITING, LEGAL, AND MORE
Skills are intentionally simple so that non engineers – such as finance analysts, recruiters, and lawyers – can participate. They can express their workflows as instructions and simple scripts, making agents more useful without needing to become full time developers.
TREAT SKILLS LIKE SOFTWARE
TESTS, EVALUATION, VERSIONS, DEPENDENCIES
The future of skills looks like modern software engineering. Skills will have tests to verify behavior, evaluation suites to measure quality, versioning for safe updates, and dependency management as they start to rely on each other or external packages.
BETTER TOOLING AROUND SKILLS
INTEGRATION, TRIGGERS, AND METRICS
Tooling will evolve so teams can define when skills should trigger, how they combine, and how to grade outputs. Metrics and dashboards will track performance and help refine skills over time, making agents more predictable and reliable in production settings.
EMERGING GENERAL AGENT ARCHITECTURE
LOOP, RUNTIME, SERVERS, SKILLS
The emerging pattern for general agents includes a central agent loop that manages prompts and responses, a runtime environment for files and code execution, connections to MCP servers for external data and tools, and a skill library that can be loaded on demand.
THE AGENT LOOP
MANAGING CONTEXT AND DECISIONS
The agent loop coordinates everything. It decides when to call the model, when to inspect the file system, when to execute code, when to invoke MCP servers, and when to load or chain skills. It is essentially the control plane for the whole system.
THE RUNTIME ENVIRONMENT
FILES AND CODE AS FIRST CLASS CITIZENS
The runtime provides a file system and code execution environment where skills live and run. This makes agent behavior explicit and inspectable. You can read the files, run the tests, and debug issues like any other software project instead of relying on opaque prompts.
MCP SERVERS AS CONNECTORS
LINKING TO THE OUTSIDE WORLD
MCP servers expose external resources – databases, SaaS apps, internal APIs – in a standard way. Instead of baking every integration into the agent, you plug in MCP servers and let skills call them. This keeps the architecture flexible and easier to extend.
THE SKILL LIBRARY
YOUR ORGANIZATION’S KNOWLEDGE BASE
The skill library is where your organization’s procedural knowledge lives. Over time, this becomes a collective, evolving asset that captures how work is done in your company, from onboarding and analysis to approvals and reporting.
CONTINUOUS LEARNING THROUGH SKILLS
AGENTS THAT IMPROVE OVER TIME
Agents can learn by updating or creating new skills based on feedback and outcomes. Improvements made for one team or project can be shared as updated skills, so the entire organization benefits instead of each agent instance learning in isolation.
CLAUDE AS A SKILL BUILDER
THE AGENT WRITES ITS OWN PLAYBOOKS
Claude itself can help create and refine skills – drafting scripts, organizing instructions, and iterating based on tests and feedback. This makes the system self improving, where the agent is both a user and an author of the skill ecosystem.
COMPUTING ANALOGY: MODEL, OS, APPS
PROCESSORS, OPERATING SYSTEMS, AND SOFTWARE
Anthropic uses a computing analogy. Models are like processors: powerful but limited without structure. Agent runtimes are like operating systems: managing resources, files, and processes. Skills are like applications: they encode real workflows and solve concrete problems for users.
DEMOCRATIZING SKILL CREATION
MILLIONS OF SMALL BUILDERS
The vision is that millions of people can build and share skills, not just AI researchers. By making skills simple, modular, and compatible with existing developer tools like Git and cloud storage, the ecosystem can grow bottom up rather than being driven only by a few large teams.
STOP REBUILDING AGENTS
EXTEND, DON’T START OVER
The core message: stop building new agents for every use case. Start with a strong general agent and extend it with skills. This approach is more scalable, easier to maintain, and better aligned with how organizations and software ecosystems actually evolve.
WHAT BUILDERS SHOULD DO NEXT
THINK IN SKILLS, NOT JUST PROMPTS
If you are building with AI, start mapping your workflows into skills: small, testable procedures in code and text. Use a general agent as the orchestrator. Over time, your skill library becomes your competitive advantage, encoding the way your product or company gets things done.