Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic

Barry Zhang and Mahesh Murag argue that agents increasingly share a common foundation, even when their assignments differ. Rather than building a separate agent with custom scaffolding for every domain, they describe a general-purpose agent coupled to a runtime environment. In this architecture, code becomes a universal interface to digital work, while the essential scaffolding can be as simple as a shell and a file system. 0:21

A financial-reporting example illustrates the mechanism. An agent can call an API to collect information, organize data in files, analyze it with Python, and synthesize the results into an appropriate document. These steps do not require a financial-reporting-specific agent architecture; they require a capable model, a usable runtime, and knowledge of how the work should actually be performed. 1:20

That final requirement is decisive. Zhang contrasts general mathematical intelligence with the practical expertise needed to handle taxes: reliable execution depends on accumulated procedural knowledge, not rediscovering the relevant rules from first principles. The speakers identify the central weakness of current agents as missing upfront context, difficulty absorbing organizational expertise, and limited improvement over time. 2:18

Agent Skills are organized collections of files containing composable procedural knowledge. Their intentionally ordinary folder-based design means humans and agents can create them with familiar computing tools, store them in Git, share them through Google Drive, or package them for teammates. The important abstraction is not a new agent framework but a portable bundle describing how to do particular work. 2:18

Skills can also contain scripts that serve as tools. Zhang describes repeatedly observing Claude recreate a Python script for styling slides, then asking it to save that script inside a skill for future reuse. Running the saved implementation makes the process more consistent and efficient while avoiding repeated regeneration of the same procedural solution. 3:33

The speakers contrast these scripts with conventional tools whose instructions may be ambiguous, whose implementations the model cannot readily modify, and whose descriptions continually occupy the context window. Code stored in a file system can remain available without always consuming context, and the agent can inspect or modify it when necessary. This positions the file system as both a working environment and a durable repository of reusable procedures. 3:33

To support larger libraries, skills use progressive disclosure. Initially, the model receives only metadata indicating that a skill exists; when the task calls for it, the agent reads the skill.md file containing the main instructions and a directory of the remaining materials. Additional files stay organized for selective access rather than being loaded into the context window all at once. 3:33

Murag groups observed skills into three broad categories: foundational skills, third-party partner skills, and organization-specific skills. Foundational examples include document skills for creating and editing professional-quality office documents, along with scientific research skills from Cadence covering EHR data analysis and improved use of common Python bioinformatics libraries. These examples show skills adding both general working capabilities and more specialized domain procedures. 4:59

Partner-created skills teach agents how to work more effectively with particular products. Browser Base built a skill for its open-source browser automation tooling, Stagehand, while Notion released skills intended to help Claude understand a Notion workspace and conduct research across it. In these cases, the expertise is not simply access to software; it is guidance for using that software effectively in context. 4:59

Enterprise skills focus on institutional knowledge that outsiders cannot be expected to infer. Murag describes conversations with Fortune 100 companies using skills to encode organizational practices and unusual internal software workflows, as well as developer productivity teams serving thousands or tens of thousands of developers and teaching agents internal code-style expectations. The common pattern is that people closest to the work can make their procedures available to shared agents. 6:10

Skills also vary substantially in complexity. A minimal implementation can be a skill.md Markdown file containing basic instructions, while more elaborate packages can include executables, binaries, code, scripts, files, and other assets. Murag reports that people in finance, recruiting, accounting, and legal are also creating skills, suggesting that extending a general agent need not be limited to people doing coding work. 7:12

The proposed architecture has several distinct layers. An agent loop manages the model’s internal context and token flow; a runtime supplies a file system and the ability to read and write code; MCP servers connect the agent to external tools and data; and a library of skills supplies task-specific procedures that can be loaded only when relevant. Instead of multiplying agent implementations, builders can adapt one general agent by selecting suitable connectivity and expertise. 9:07

The relationship between MCP and skills is complementary rather than competitive. Murag describes developers building skills that coordinate multiple MCP tools into more complex workflows, with MCP providing external connectivity and skills providing the expertise required to use those connections productively. The distinction separates what an agent can reach from what it knows how to accomplish. 8:08

The speakers say this pattern has already informed Anthropic offerings in financial services and life sciences, each combining MCP servers with skills intended to make Claude more effective for professionals in those domains. Their claim is architectural rather than quantitative: the transcript does not provide measured performance gains, comparative evaluation results, or detailed implementation evidence for those offerings. 10:09

As skills accumulate more code and supporting material, the speakers expect them to require stronger engineering practices. Murag specifically identifies testing and evaluation, including tools that determine whether an agent loads or triggers the appropriate skill for a given task and whether the resulting output meets the intended quality standard. These capabilities are presented as areas to develop, not as already-complete solutions. 7:12

Versioning is another unresolved operational requirement because changing a skill changes the behavior of the agent using it. Murag argues that teams should be able to track that evolution and preserve a clear lineage. He also proposes explicit references to other skills, MCP servers, and packages or dependencies in the runtime environment so behavior becomes more predictable across different execution contexts. 11:14

The tradeoff is that simplicity at the interface does not eliminate complexity inside the package. A skill may start as a short instruction file, but sophisticated versions could eventually take weeks or months to build and maintain. Composability also introduces questions about triggering, compatibility, dependencies, quality assurance, and whether a given environment contains everything the skill requires. 7:12

The longer-term vision is a collective knowledge base curated by people and agents across an organization. In that model, feedback and institutional procedures become reusable capabilities that benefit multiple agents and new team members, rather than remaining trapped in a single conversation. Murag also extends this idea beyond individual organizations: a useful skill created elsewhere could improve another team’s agents, much as externally created MCP servers can expand an agent’s usefulness. 11:14

Zhang frames skills as a concrete step toward continuous learning because a standardized, persistent artifact can be used by a future version of the same agent. He explicitly limits the claim: skills do not capture every kind of memory or information, only procedural knowledge applicable to particular tasks. Their flexibility also allows capabilities to be acquired, revised, or removed as circumstances change, particularly when relevant information changes frequently. 13:20

Agents can participate in creating this knowledge layer themselves: Zhang says Claude can already create skills using a skill creator skill. His closing analogy casts models as processors, agent runtimes as operating systems, and skills as the application layer where developers encode domain expertise and distinctive approaches. The practical conclusion is to invest creative effort in reusable capabilities rather than repeatedly rebuilding the underlying general-purpose agent. 14:24