Anthropic Drops Custom Agent Scaffolding for Modular Code Skills

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

AI Engineer

Anthropic argues that bespoke agent architectures are obsolete because pairing a minimal bash runtime with dynamically loaded skill folders provides all the domain expertise required for specialized enterprise work.

AI-assisted summary of Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic — original source. Check the original for full context.

Source published:

Key ideas

  • Anthropic demonstrates that bespoke agent scaffolding can be replaced by a minimal code runtime consisting simply of a bash shell and a file system, using code as a universal interface for digital work. (0:00)
  • To overcome the gap where raw model intelligence lacks domain execution expertise, Anthropic introduced Agent Skills—composable, folder-based bundles of procedural guidance and executable scripts loaded via progressive disclosure. (2:08)
  • In the modern enterprise agent architecture, Model Context Protocol (MCP) servers handle external connectivity and live data pipes, while Skills provide the workflow orchestration and operational expertise. (7:18)
  • Skills enable continuous agent learning without fine-tuning: agents can document their own operational discoveries into reusable scripts, compounding institutional knowledge over time. (12:55)

Detailed notes

## Background Published by the AI Engineer channel on YouTube on December 8, 2025, this talk features Anthropic's Barry Zhang and Mahesh Murag discussing how to bridge the gap between general agent intelligence and real-world domain expertise. According to the page description, the session explores Anthropic's design of 'Skills'—a minimal, composable form factor for packaging procedural knowledge that agents can dynamically load, share, and ultimately author from experience.

## TL;DR Barry Zhang and Mahesh Murag argue that developers should stop building bespoke agent loops and instead rely on thin code runtimes powered by 'Skills'—simple folder-based directories containing instructions, references, and executable scripts. By combining skills for procedural domain knowledge with the Model Context Protocol (MCP) for external connectivity, agents can dynamically load specialized workflows through progressive disclosure without cluttering the context window. The speakers demonstrate how treating skills like traditional software through testing and versioning enables shared organizational capabilities and continuous learning, allowing agents to iteratively write and refine their own tools. Drawing a historical parallel to personal computing, they frame models as processors, runtimes as operating systems, and skills as the true application layer driven by human domain expertise.

## Atmosphere & style The talk has a crisp, pragmatic, and forward-looking engineer-to-engineer energy, blending concrete architectural diagrams with accessible humor—such as contrasting mathematical genius with seasoned tax preparation experience. Barry and Mahesh share an easy, collaborative rhythm on stage, methodically stripping away hype to reframe complex agent development around straightforward primitives like bash and file systems. It feels like an authoritative insider briefing, turning what could be an overwhelming systems challenge into an inspiring, practical invitation to build the application layer of artificial intelligence.

## Bulletin - [00:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=0s) Anthropic demonstrates that bespoke agent scaffolding can be replaced by a minimal code runtime consisting simply of a bash shell and a file system, using code as a universal interface for digital work. - [02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) To overcome the gap where raw model intelligence lacks domain execution expertise, Anthropic introduced Agent Skills—composable, folder-based bundles of procedural guidance and executable scripts loaded via progressive disclosure. - [07:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=438s) In the modern enterprise agent architecture, Model Context Protocol (MCP) servers handle external connectivity and live data pipes, while Skills provide the workflow orchestration and operational expertise. - [12:55](https://www.youtube.com/watch?v=CEvIs9y1uog&t=775s) Skills enable continuous agent learning without fine-tuning: agents can document their own operational discoveries into reusable scripts, compounding institutional knowledge over time.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=0s) Specialized agent scaffolding has largely converged onto a universal, thin code execution runtime powered by bash and local file system access. - [02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) High model intelligence cannot replace domain expertise; deriving nuanced procedures or business logic from first principles produces inconsistent results. - [02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) Agent Skills are packaged as ordinary file folders to ensure interoperability with standard tools like Git and cloud storage without proprietary wrappers. - [02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) Storing executable scripts inside skill folders avoids context bloat, prevents cold-start tool failure loops, and allows models to modify tools on the fly. - [02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) Progressive disclosure preserves context windows by exposing only high-level skill metadata until a task specifically warrants reading detailed instructions. - [07:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=438s) The division of labor between primitives is clear: MCP servers supply external data pipes, whereas Skills supply procedural domain expertise and orchestration. - [07:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=438s) File-and-folder skill definitions democratize agent customization, enabling non-technical users across legal, recruiting, and accounting to build capabilities. - [10:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=600s) Launching an agent into vertical enterprise markets like finance and life sciences requires pairing general runtimes with domain-specific MCPs and curated skills rather than bespoke agent loops. - [10:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=600s) As skills grow in complexity, builders must apply software engineering rigor, including trigger evaluations, version lineage, and dependency declarations. - [11:45](https://www.youtube.com/watch?v=CEvIs9y1uog&t=705s) Shared organizational skill repositories create compounding network effects, where continuous refinements from team members improve agent performance company-wide. - [11:45](https://www.youtube.com/watch?v=CEvIs9y1uog&t=705s) Centralized team skills streamline employee onboarding by providing day-one access to an agent already primed on internal operating procedures and edge cases. - [12:55](https://www.youtube.com/watch?v=CEvIs9y1uog&t=775s) Skills serve as an effective mechanism for continuous learning, allowing models to retain and update operational procedures across sessions without costly fine-tuning. - [14:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=860s) In the computing analogy for modern AI, foundation models represent hardware processors, agent runtimes act as operating systems, and skills serve as the application layer.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=0s) From Specialized Agents to Universal Code Runtimes

Reflecting on how quickly the field has shifted since their previous talk—when the community was still grappling with defining what an agent even is—Barry Zhang and Mahesh Murag point out that while many people now use agents daily, noticeable performance gaps remain. Agents have intelligence and raw capability, yet they routinely lack the specialized domain expertise required for practical, real-world execution. The ecosystem has nevertheless matured rapidly: the Model Context Protocol (MCP) emerged as the standard for connectivity, Claude Code launched as Anthropic's flagship coding agent, and the Claude Agent SDK delivered an out-of-the-box, production-ready framework.

These breakthroughs led to an architectural realization. Teams originally assumed that deploying agents across varied domains would necessitate completely distinct tools and bespoke scaffolding for every separate use case. Instead, Anthropic discovered that code serves as a universal interface to digital work. Barry explains that when examining an agent like Claude Code, the underlying runtime collapses down to something remarkably thin: just a bash shell and a file system. A workflow like assembling a financial report can be handled end-to-end through code—the model invokes APIs to fetch research data, stores and structures files locally, performs analysis using Python, and renders the synthesized insights into whatever file format is needed.

As Barry Zhang puts it: > “Put simply we think code is all we need”

- **Universal Agent Scaffolding:** Moving away from heavy custom agent loops for each task toward a lightweight environment centered on bash, file manipulation, and code execution. - **Claude Code as General Agent:** Proving that an agent designed for code can seamlessly execute knowledge tasks like financial data gathering, quantitative analysis, and multi-format document authoring.

```mermaid flowchart LR accTitle: Thin Scaffolding Architecture accDescr: Diagram showing how a thin bash and file system layer coordinates data, analysis, and outputs.

subgraph Runtime["Runtime Environment"] B["Bash Shell"] FS["File System"] end

subgraph Actions["Model Operations via Code"] direction TB API["Pull Data & Research (APIs)"] PY["Data Analysis (Python)"] OUT["Synthesize Insights (Outputs)"] end

B --- FS Runtime --> Actions ```

---

[02:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=128s) The Expertise Gap and the Design of Agent Skills

Even with a thin and highly scalable code runtime, developers slam into a fundamental roadblock: domain expertise. Barry highlights this dilemma by comparing mathematical horsepower with seasoned practice: who would you trust to file your taxes—a 300-IQ mathematical genius like Mahesh, or an experienced tax professional like Barry?

As Barry Zhang points out: > “I would pick Barry every time I don want Mahesh to figure out the 2025 tax code from first principles I need consistent execution from a domain expert”

Current agents mirror this limitation: they are brilliant problem-solvers, but they lack procedural context upfront, struggle to absorb nuanced expertise dynamically, and fail to compound knowledge over time. To solve this, the team designed Agent Skills. At their core, skills are simply organized collections of files within folders that package composable, procedural knowledge. The folder form factor is an intentional design choice: it is universally compatible with existing tools like Git version control, Google Drive, or standard ZIP archives, making it accessible to both humans and agents without proprietary wrappers.

Within these skill folders, procedural knowledge is paired with executable scripts used as tools. Traditional tool interfaces present major pain points: prompt instructions are frequently ambiguous, the tool specifications permanently crowd the model's active context window, and if an execution failure occurs, the agent cannot easily modify the underlying tool definition, trapping it in a cold-start failure loop. By contrast, scripts stored in the file system are self-documenting, can be modified directly by the model on the fly, and stay offloaded until invoked. For instance, after repeatedly watching Claude write the same styling code from scratch when generating slides, the team instructed Claude to save the Python script into a skill folder as a reusable tool for its future self. To keep the context window clear across hundreds of skills, skills rely on progressive disclosure: only lightweight skill metadata is initially exposed to the agent; full instructions within `skill.md` and related directory assets are read into context only when that specific skill is invoked.

- **The Expertise Dilemma:** Raw model intelligence cannot replace domain experience; deriving complex business or legal rules from first principles yields brittle and inconsistent results. - **Folders as the Primitive:** Skills avoid proprietary abstractions by utilizing standard directories containing instructions, references, and executable scripts. - **Code vs. Static Tools:** Embedding scripts inside skills avoids context bloat, allows agent modification during run failures, and creates self-reinforcing capabilities. - **Progressive Disclosure:** Runtime agents see only high-level metadata until a task demands reading the full `skill.md` file and its accompanying assets.

---

[05:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=300s) Ecosystem Adoption Across Partners and Enterprises

Just five weeks after launch, this simple folder-based architecture spurred an ecosystem numbering thousands of skills. Mahesh categorizes these implementations into three primary tiers: foundational skills, third-party partner integrations, and enterprise-internal skills.

Anthropic kicked off foundational skills by releasing document skills that allow Claude to design and edit office documents with professional quality. In the broader ecosystem, organizations such as Cadence developed scientific research skills enabling Claude to carry out EHR data analysis and interact with standard Python bioinformatics packages far more effectively than baseline models could. Meanwhile, software vendors build skills to optimize agent interaction with their own platforms: 1. **BrowserBase:** Packaged a skill for their open-source browser automation tool, Stagehand, equipping Claude to navigate complex web applications and perform interactive browser workflows. 2. **Notion:** Released skills designed to help Claude parse workspace hierarchies and execute deep research queries across an entire company workspace. 3. **Enterprise Teams:** Fortune 100 enterprises leverage skills to document proprietary internal software idiosyncrasies, while central developer productivity teams serving tens of thousands of engineers deploy skills to enforce internal code-style guides and standard operating procedures.

- **Foundational Capabilities:** Core enhancements developed directly by Anthropic and domain specialists for office document authoring and advanced bioinformatics analysis. - **Partner Tooling:** Vendor-authored skills (e.g., BrowserBase's Stagehand automation, Notion's workspace discovery) that enhance model proficiency on external products. - **Internal Knowledge Bases:** Corporate deployments targeting custom developer workflows, proprietary systems, and organizational best practices.

---

[07:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=438s) Emerging Trends and the Unified Agent Architecture

As skills expand across industries, Mahesh notes several key shifts in their construction, utility, and target demographic. While early implementations were often single `skill.md` files containing simple prompts, skills are increasingly maturing into comprehensive software bundles loaded with binaries, executables, helper code, and static assets. Where initial authoring took minutes, future production skills may represent weeks or months of engineering and ongoing maintenance. Furthermore, skills operate synergistically with Model Context Protocol (MCP) servers: MCP provides the pipe for raw connectivity and remote data transfer, while skills supply the operational expertise and orchestration logic to chain those MCP endpoints together into cohesive workflows. Non-technical users across legal, recruiting, finance, and accounting departments are also rapidly building skills, confirming that file-based procedural packaging makes agent customization universally accessible.

As Mahesh Murag summarizes the division of labor between tools and procedures: > “And in these cases, MCP is providing the connection to the outside world, while skills are providing the expertise.”

This convergence establishes an emerging standard architecture for general-purpose agents. At its center sits a focused agent loop managing context and token flow, wired into a runtime environment equipped with bash and file system access. This core hooks out to external tools via MCP servers, while maintaining access to a broad library of hundreds or thousands of skills stored on disk, selectively paging them into the active context window only when the task demands it.

```mermaid flowchart TD accTitle: Unified General Agent Architecture accDescr: Structural overview showing the agent loop managing context, connected to a runtime environment, external MCP tools, and a dynamic skill library.

subgraph Core["Core Agent Layer"] Loop["Agent Loop (Token & Context Management)"] Env["Runtime Environment (File System & Bash)"] Loop --- Env end

subgraph Integration["External & Domain Knowledge"] MCP["MCP Servers (External Connectivity & Data)"] Skills["Skill Library (Hundreds of Skills on Disk)"] end

Loop <-->|"Tools & Live Data"| MCP Loop <-->|"Progressive Disclosure (Dynamic Loading)"| Skills ```

- **Increasing Asset Sophistication:** Evolution from pure markdown prompt instructions to complete packages featuring executables, scripts, and documentation. - **Division of Responsibilities:** MCP handles external data connectivity, whereas Skills package workflow orchestration, logic, and domain mastery. - **Democratized Authoring:** Non-technical operators in legal, finance, and HR construct operational skills, proving the ergonomics of file-based customization. - **Dynamic Skill Registry:** Agents scale their functional breadth by referencing extensive skill repositories on disk, loading instructions into the active context window purely on demand.

[10:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=600s) Deploying Claude to Verticals and Treating Skills Like Software

Equipping an agent with capabilities in an entirely new domain does not require re-architecting the agent from scratch; it simply requires pairing it with the appropriate Model Context Protocol (MCP) servers and a curated library of skills. Anthropic has already put this pattern into active production to roll out Claude across specialized enterprise sectors. Just five weeks after internally launching Skills, the team introduced dedicated offerings tailored for financial services and life sciences. Each vertical package combines targeted MCP servers with domain-specific procedural skills, immediately elevating Claude's practical utility for analysts, researchers, and domain professionals.

Looking forward, as skills evolve beyond simple instructions into sophisticated multi-step workflows, the focus must shift toward bringing traditional software engineering rigor into the skill ecosystem. As Mahesh Murag explains, “As they start to become more complex, we really want to support developers, enterprises, and other skill builders by starting to treat skills like we treat software.” This initiative centers on three technical pillars:

```mermaid flowchart TD accTitle: Treating Skills Like Software accDescr: Three core software engineering disciplines applied to AI agent skills. subgraph Engineering["Treating Skills Like Software"] TE["Testing & Evaluation"] VR["Versioning & Lineage"] DP["Dependencies & Composability"] end TE -->|"Verifies"| Out["Trigger Accuracy & Output Quality"] VR -->|"Tracks"| Hist["Behavioral Drift Over Time"] DP -->|"References"| Env["Other Skills, MCP Servers & Packages"] ```

- **Testing and Evaluation:** Developing robust tooling to guarantee that agents accurately identify, trigger, and load relevant skills at the right moment, while benchmark tooling verifies that final outputs meet domain-quality bars. - **Versioning and Lineage:** Tracking edits and architectural iterations systematically so teams can trace shifts in agent behavior and maintain a dependable history over time. - **Dependencies and Composability:** Enabling skills to explicitly declare dependencies on other skills, specific MCP servers, and local environment packages, ensuring agents execute reliably across differing runtime environments and unlock complex, chained behaviors.

---

[11:45](https://www.youtube.com/watch?v=CEvIs9y1uog&t=705s) Collective Knowledge Bases, Sharing, and the Compounding Ecosystem

The long-term enterprise value of skills lies in their capacity for distribution and network effects. Mahesh Murag and Barry Zhang envision organizations operating around a living repository of shared institutional capabilities rather than isolated personal prompts. As Mahesh Murag points out, “And the vision that excites us most is one of a collective and evolving knowledge base of capabilities that's curated by people and agents inside of an organization.” Every time an employee interacts with an agent, supplies operational critique, or refines a task workflow, that procedural learning feeds back into the shared skill catalog, elevating every instance of Claude deployed across the company.

This organizational dynamic fundamentally transforms employee onboarding. When a newcomer joins a team and opens Claude on day one, the model is not a blank slate asking basic procedural questions; it already possesses the team's operational playbook, understands daily workflows, and knows the exact formatting preferences and edge cases that matter to the group. Moreover, this compounding loop is designed to breach corporate boundaries: much like the open MCP ecosystem where a developer across the globe can build an integration that benefits everyone, publicly shared skills allow community-authored capabilities to make agents everywhere more capable, reliable, and immediately useful.

---

[12:55](https://www.youtube.com/watch?v=CEvIs9y1uog&t=775s) Continuous Learning: Agents Authoring and Evolving Their Own Skills

The vision of an evolving operational knowledge base reaches its logical endpoint when the agent begins writing, updating, and pruning its own skills based on lived experience. Skills serve as a tangible mechanism for continuous learning, sidestepping the high costs and latency of continual fine-tuning. By relying on a standardized file-and-folder format, skills offer a crucial operational guarantee that Barry Zhang emphasizes: “Anything that Claude writes down can be used efficiently by a future version of itself.” This ensures that procedural learning remains genuinely transferable across tasks, sessions, and model updates.

Rather than attempting to hoard every piece of conversational trivia into an unstructured memory buffer, skills provide a structured container strictly for actionable procedural knowledge. Because skills exist in context, they grant immense flexibility: Claude can acquire a new operational technique instantly, iterate on the documentation as project requirements shift, and discard outdated practices without friction. Barry Zhang underscores the ultimate benchmark of this paradigm: “Our goal is that Claude on day 30 of working with you, is going to be a lot better on Claude on day one.” Claude already leverages this capability internally through Anthropic's dedicated Skill Creator skill, which observes user intent and codifies functional skills automatically.

---

[14:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=860s) The Computing Analogy: From Processors to Operating Systems to Applications

To place this shift in historical context, Barry Zhang frames the emerging agent stack through the evolution of personal computing. Foundation models are analogous to raw hardware processors: they require billions of dollars in capital investment and harbor tremendous compute potential, yet on their own, they remain incomplete tools for end users. The computing industry solved this bottleneck by developing operating systems to manage scheduling, file access, and peripheral orchestration. In modern AI, the emerging agent runtime serves as this operating system, managing context windows and coordinating the clean, scalable flow of tokens into and out of the model.

```mermaid flowchart LR accTitle: The AI Agent Computing Analogy accDescr: A structural comparison mapping processors, operating systems, and applications to models, agent runtimes, and skills. subgraph Computing["Traditional Computing"] P["Processor"] --> OS["Operating System"] OS --> App["Applications"] end subgraph AgentStack["Modern Agent Stack"] M["Foundation Model"] --> R["Agent Runtime"] R --> S["Skills (Folder Files)"] end P -.->|"Analogy"| M OS -.->|"Analogy"| R App -.->|"Analogy"| S ```

The true economic and creative value of personal computing was not captured entirely by processor manufacturers or OS developers; it was unlocked when millions of software engineers began building applications that encoded domain expertise, workflows, and unique creative perspectives. Skills represent that exact application layer for artificial intelligence. By allowing anyone to package deep procedural know-how simply by dropping text and code files into a directory, the barrier to building domain-expert intelligence vanishes. Barry Zhang wraps up the talk with an open challenge to the audience: “So we think it's time to stop rebuilding agents and start building skills instead.”

- **The Processor Layer:** Massive capital-intensive foundation models that supply raw reasoning power. - **The Operating System Layer:** Agent runtimes engineered to get the right tokens to and from the model efficiently. - **The Application Layer:** Skills and folder-based procedural knowledge that encode human domain expertise and creative problem-solving.

## Notable quotes > [14:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=860s) So we think it's time to stop rebuilding agents and start building skills instead. — Barry Zhang

> [12:55](https://www.youtube.com/watch?v=CEvIs9y1uog&t=775s) Anything that Claude writes down can be used efficiently by a future version of itself. — Barry Zhang

> [07:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=438s) MCP is providing the connection to the outside world, while skills are providing the expertise. — Mahesh Murag

## Mentioned Barry Zhang, Mahesh Murag, Anthropic, Claude, Claude Code, Claude Agent SDK, Model Context Protocol, Cadence, BrowserBase, Stagehand, Notion, Git, Google Drive, Python

## Video description In the past year, we've seen rapid advancement of model intelligence and convergence on agent scaffolding. But there's still a gap: agents often lack the domain expertise and specialized knowledge needed for real-world work. We think Skills are the solution—a minimal form factor for packaging procedural knowledge that agents can dynamically load. It's a portable, composable approach to giving one agent capabilities across domains. In this talk, we'll share how we built Skills at Anthropic, the network effects we're observing, and where we believe this leads: agents writing their own Skills from experience. Our thesis: equipping agents for real-world work means building reusable expertise.

Barry: https://twitter.com/barry_zyj Mahesh: https://twitter.com/MaheshMurag

---

Explore this talk's slides, transcript, key takeaways and resources on its official AI Engineer page: https://ai.engineer/talks/CEvIs9y1uog-agent-skills

---

[Source](https://www.youtube.com/watch?v=CEvIs9y1uog)

Reading summary

Anthropic's Barry Zhang and Mahesh Murag argue that developers should stop engineering custom agent architectures for separate domains, proposing instead a thin code execution runtime augmented by modular, folder-based 'Skills' that package procedural domain expertise. Universal Code Runtimes Over Custom Scaffolding (0:00) Barry Zhang and Mahesh Murag assert that rather than building specialized scaffolding for every individual agent use case, digital work collapses naturally into a universal code interface. In systems like Claude Code, the underlying runtime requires little more than a bash shell and a file system. Through this minimal scaffolding, a model can execute complex multi-step workflows—such as querying research APIs, manipulating local data in Python, and generating formatted deliverables—without bespoke task loops. Folder Primitives and Progressive Disclosure (2:08) High model reasoning capacity cannot compensate for missing domain experience, which Zhang illustrates by noting that users prefer an experienced tax professional over a high-IQ novice attempting to derive tax code from first principles. To bridge this gap, Anthropic introduced Agent Skills: standard directories containing procedural documentation, reference files, and executable scripts. Storing tools as executable scripts within the file system allows models to modify tools dynamically when errors occur and avoids crowding context windows with static tool definitions. To scale across hundreds of skills without context bloat, agents rely on progressive disclosure, exposing only lightweight metadata initially and reading full instructions in skill.md only when a task demands it. Orchestrating External Tools with Domain Knowledge (5:00) Within five weeks of launch, external partners and enterprises built thousands of skills spanning office document generation, bioinformatics research with Cadence, browser automation via BrowserBase's Stagehand, and Notion workspace discovery. Murag emphasizes a distinct division of labor between protocols and procedures: the Model Context Protocol (MCP) provides the pipe for external data connectivity, while skills supply the operational expertise and orchestration logic to chain those endpoints into cohesive workflows. Because skills rely on standard file directories rather than proprietary wrappers, non-technical personnel across legal, finance, and recruiting can author domain workflows directly, democratizing how agent behaviors are defined and customized. Treating Skills as Software for Continuous Learning (10:00) As skills evolve from basic prompts into multi-step software packages with binaries and helper code, Murag highlights the need to apply traditional software engineering rigor. This includes testing and evaluation to ensure accurate skill triggering, versioning to track behavioral drift over time, and explicit dependency management across MCP servers and packages. Skills also provide a structured mechanism for continuous learning without expensive fine-tuning. Because agents can write, edit, and store scripts via dedicated utilities like Anthropic's Skill Creator, procedural updates persist across sessions. This design enables a compounding, shared institutional knowledge base where onboarding models inherit an organization's existing playbooks immediately. Framing this architectural shift through computing history, Zhang compares foundation models to raw processors and agent runtimes to operating systems. The speakers conclude that the primary economic and operational value will reside in skills as the application layer, allowing practitioners to encode specialized human expertise into standard text and code directories rather than rebuilding agents from scratch.

Source quotes

[14:20] Barry Zhang: So we think it's time to stop rebuilding agents and start building skills instead. [12:55] Barry Zhang: Anything that Claude writes down can be used efficiently by a future version of itself. [7:18] Mahesh Murag: MCP is providing the connection to the outside world, while skills are providing the expertise.

Original transcript

[0:00] . All right, good morning, and thank you for having us again. Last time we were here, we're still figuring out what an agent even is. Today, many of us are using agents on a daily basis. But we still notice gaps. We still have sloths, right? Agents have intelligence and capabilities, but not always the expertise that we need for real work. I'm Barry. This is Mahesh. We created agent skills. In this talk, we'll show you why we stopped building agents and started building skills instead. A lot of things have changed since our last talk. MCP became the standard for agent connectivity. Cloud Code, our first coding agent, launched through the world. And our Cloud Agent SDK now provides a production-ready agent out of the box. We have a more mature ecosystem, and we're moving towards a new paradigm for agents. That paradigm is a tighter coupling between the model and the runtime environment Put simply we think code is all we need We used to think agents in different domains will look very different. Each one will need its own tools and scaffolding. And that means we'll have a separate agent for each use case for each domain. While customization is still important for each domain, the agent underneath is actually more universal than we thought. What we realized is that code is not just a use case, but a universal interface to the digital world. After we built Cloud Code, we realized that Cloud Code is actually a general purpose agent. Think about generating a financial report. The model can call the API to pull in data and do research. It can organize that data in the file system. You can analyze it with Python, and then synthesize the insight in all file format, all through code. The core scaffolding can suddenly become as thin as just bash, and file system, which is great and really scalable, but we very quickly ran into a different problem. And that problem is domain expertise. Who do you want doing your taxes? Is it going to be Mahesh, the 300 IQ mathematical genius, or is it Barry, an experienced tax professional? I would pick Barry every time I don want Mahesh to figure out the 2025 tax code from first principles I need consistent execution from a domain expert Agents today are a lot like Mahesh They're brilliant, but they lack expertise. No more slow. They can do amazing things when you really put in effort and give proper guidance, but they're often missing the important context up front. They can't really absorb your expertise super well, and they don't learn over time. That's why we created agent skills. Skills are organized collections of files that package composable procedural knowledge for agents. In other words, they're folders. This simplicity is deliberate. We want something that anyone, human or agent, can create and use as long as they have a computer. These also work with what you already have. You can version them in Git, you can throw them in Google Drive, and you can zip them up and share it with your team. We have used files as a primitive for decades, and we like them. So why change now? Because of that, skills can also include a lot of scripts as tools. Traditional tools have pretty obvious problems Some tools have poorly written instructions that are pretty ambiguous And when the model is struggling it can really make a change to the tool So it just kind of stuck with a code start problem And they always live in the context window Code solves some of these issues. It's self-documenting. It is modifiable. And it can live in the file system until they're really needed and used. Here's an example of a script inside of a skill. We kept seeing Cloud write the same Python script over and over again to apply styling to slides. So we just ask Cloud to save it inside of the skill as a tool for its future self. Now we can just run the script, and that makes everything a lot more consistent and a lot more efficient. At this point, skills can contain a lot of information. And we want to protect the context window so that we can fit in hundreds of skills and make them truly composable. That's why skills are progressively disclosed. At runtime, only this metadata is shown to the model just to indicate that it has this skill. When an agent needs to use a skill, you can read in the rest of the skill.md, which contains the core instruction and directory for the rest of the folder. Everything else is just organized for ease of access. So that's all skills are. They're organized folders with scripts as tools. [5:00] Our launch five weeks ago, this very simple design, has translated into a very quickly growing ecosystem of thousands of skills. And we've seen this be split across a couple of different types of skills. There are foundational skills, third-party skills created by partners in the ecosystem, and skills built within an enterprise and within teams. To start, foundational skills are those that give agents new general capabilities or domain-specific capabilities that it didn't have before. We ourselves, with our launch, built document skills that give Claude the ability to create and edit professional-quality office documents. We're also really excited to see people like Cadence build scientific research skills that give Claude new capabilities like EHR data analysis and using common Python bioinformatics libraries better than it could before. We've also seen partners in the ecosystem build skills that help Claude better with their own software and their own products. BrowserBase is a pretty good example of this. They built a skill for their open source browser automation tooling, StageHand. And now Claude equipped this skill with stagehand, can now go navigate the web and use a browser more effectively to get work done. And Notion launched a bunch of skills that help Claude better understand your Notion workspace and do deep research over your entire workspace. And I think where I've seen the most excitement and traction with skills is within large enterprises. These are company and team-specific skills built for an organization. We've been talking to Fortune 100s that are using skills as a way to teach agents about their organizational best practices and the weird and unique ways that they use this bespoke internal software. We're also talking to really large developer productivity teams. These are teams serving thousands or even tens of thousands of developers in an organization that are using skills as a way to deploy agents like Cloud Code and teach them about code-style best practices and other ways that they want their developers to work internally. So all of these different types of skills are created and consumed by different people inside of an organization or in the world, but what they have in common is anyone can create them, and they give agents new capabilities that they didn't have before. Thank you. So as this ecosystem has grown, we've started to observe a couple of interesting trends. First, skills are starting to get more complex. The most basic skill today can still be a skill.md markdown file with some prompts and some really basic instructions. But we're starting to see skills that package software, executables, binaries, files, code, scripts, assets, and a lot more. And a lot of the skills that are being built today might take minutes or hours to build and put into an agent. But we think that increasingly, much like a lot of the software we use today, these skills might take weeks or months to build and be maintained. We're also seeing that this ecosystem of skills is complementing the existing ecosystem of MTP servers that was built up over the course of this year. Developers are using and building skills that orchestrate workflows of multiple MCP tools stitched together to do more complex things with external data and connectivity. And in these cases, MCP is providing the connection to the outside world, while skills are providing the expertise. And finally, and I think most excitingly for me personally, is we're seeing skills that are being built by people that aren't technical. These are people in functions like finance, recruiting, accounting, legal, and a lot more. And I think this is pretty early validation of our initial idea that skills help people that aren't doing coding work extend these general agents. And they make these agents more accessible for the day-to-day of what these people are working on. So So tying this all together, let's talk about how these all fit into this emerging architecture of general agents. First, we think this architecture is converging on a couple of things. The first is this agent loop that helps manage the model's internal context and manages what tokens are going in and out. And this is coupled with a runtime environment that provides the agent with a file system and the ability to read and write code. This agent, as many of us have done throughout this year, can be connected to MCP servers. And these are tools and data from the outside world that make the agent more relevant and more effective. And now we can give the same agent a library of hundreds or thousands of skills that it can decide to pull into context only at runtime when it's deciding to work on a particular task. Today, giving an [10:00] 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. And this emerging pattern of an agent with an MCP server and a set of skills is something that's already helping us at Anthropic deploy Claude to new verticals. Just after we launched Skills five weeks ago, we immediately launched new offerings in financial services and life sciences. And each of these came with a set of MCP servers and a set of skills that immediately make Claude more effective. for professionals in each of these domains. We're also starting to think about some of the other open questions and areas that we want to focus on for how skills evolve in the future. As they start to become more complex, we really want to support developers, enterprises, and other skill builders by starting to treat skills like we treat software. This means exploring testing and evaluation. Better tooling to make sure that these agents are loading and triggering skills at the right time and for the right task. And tooling to help measure the output quality of an agent equipped with the skill to make sure that's on par with what the agent is supposed to be doing. We'd also like to focus on versioning. As the skill evolves and the resulting agent behavior evolves, we want this to be clearly tracked and to have a clear lineage over time. And finally, we'd also like to explore skills that can explicitly depend on and refer to either other skills, MCP servers, and dependencies and packages within the agent's environment. We think that this is going to make agents a lot more predictable in different runtime environments. And the composability of multiple skills together will help agents like Claude elicit even more complex and relevant behavior. from these agents. Overall, these set of things should hopefully make skills easier to build and easier to integrate into agent products, even those besides plot. Thank you. Finally, a huge part of the value of skills, we think, is going to come from sharing and distribution. Barry and I think a lot about the future of companies that are deploying these agents at scale. And the vision that excites us most is one of a collective and evolving knowledge base of capabilities that's curated by people and agents inside of an organization. We think skills are a big step towards this vision. They provide the procedural knowledge for your agents to do useful things. And as you interact with an agent and give it feedback, and more institutional knowledge, it starts to get better, and all of the agents inside your team and your org get better as well. And when someone joins your team and starts using Claude for the first time, it already knows what your team cares about. It knows about your day-to-day, and it knows about how to be most effective for the work that you're doing. And as this grows and this ecosystem starts to develop even more, this compounding value is going to extend outside of just your org and into the broader community. So just like when someone else across the world builds an MCP server that makes your agent more useful, a skill built by someone else in the community will help make your own agents more capable, reliable, and useful as well. Thank you. This vision of an evolving knowledge base gets even more powerful when Claw starts to create these skills. We design skills specifically as a concrete steps towards continuous learning. When you first start using Cloud, this standardized format gives a very important guarantee. Anything that Cloud writes down can be used efficiently by a future version of itself. This makes the learning actually transferable. As you build up the context, Skills makes the concept of memory more tangible. They don't capture everything. They don't capture every type of information, just procedural knowledge that Cloud can use on specific tasks. We have worked with Cloud for quite a while. The flexibility of skills matters even more. Cloud can acquire new capabilities instantly, evolve them as needed, and then drop the ones that become obsolete. This is what we have always known. The power of in-context learning makes this a lot more cost effective for information that change on a daily basis. Our goal is that Cloud on day 30 of working with you, is going to be a lot better on Cloud on day one. ClockLight already creates skills for you today using our skill creator skill. And we're going to continue pushing in that direction. Thank you. We're going to conclude by comparing the agent stack to what we have already seen in computing. In a rough analogy, models are like processors. Both require massive investment and contain immense potential, but only so useful by themselves. Thank you. Then we start building an operating system. The OS made processors far more valuable by orchestrating the processes, resources, and data around the processor. In AI, it would [15:00] the agent runtime is starting to play this role. We're all trying to build the cleanest, most efficient, and most scalable abstractions to get the right tokens in and out of the model. But once we have a platform, the real value comes from applications. A few companies build processors and operating systems, but millions of developers, like us, have built softwares that encoded domain expertise and are unique points of view. We hope that skills can help us open up this layer for everyone. This is where we get creative and solve concrete problems for ourselves, for each other, and for the world. just by putting stuff in the folder. So skills are just the starting point. To close out, we think we're now converging on this general architecture for general agents. We've created skills as a new paradigm for shipping and sharing new capabilities. So we think it's time to stop rebuilding agents and start building skills instead. And if you're excited about this, come work with us and start building some skills today. Thank you.