# Don't Build Agents, Build Skills Instead

Barry Zhang · Mahesh Murag

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/CEvIs9y1uog-agent-skills) · [Video](https://www.youtube.com/watch?v=CEvIs9y1uog)

## Stop Rebuilding Agents: Package Domain Expertise as Skills

Barry Zhang and Mahesh Murag explain how reusable folders of instructions, scripts, and assets can give general-purpose agents specialized expertise without rebuilding their underlying architecture.

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 288 seconds](https://ai.engineer/api/talk-essay-media/b690a074684a670091beafeaba028c14f9648794ee30e4625db9a900b8d8fe84)

Stop Rebuilding Agents: Package Domain Expertise as Skills

### The real gap is expertise, not intelligence

[0:21](https://www.youtube.com/watch?v=CEvIs9y1uog&t=21s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=21s) [1:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=80s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=80s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=138s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 71 seconds](https://ai.engineer/api/talk-essay-media/84d499ffb1212419db3495ac7ef87fd166805ee7f4dbc68f610f9353561cf8cb)

The real gap is expertise, not intelligence

- General-purpose agents can operate across domains using code, a shell, and a file system.
- Financial reporting can combine API research, file organization, Python analysis, and document synthesis.
- Reliable specialized work requires procedural expertise and upfront context, not intelligence alone.

### A skill is a folder that makes procedures reusable

[2:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=138s)

**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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=138s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s) [4:39](https://www.youtube.com/watch?v=CEvIs9y1uog&t=279s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 292 seconds](https://ai.engineer/api/talk-essay-media/0178b754411c2110bc1b4c37ecd86ac8a526abcbf71cbd75c9c454101279b359)

A skill is a folder that makes procedures reusable

- Skills package composable procedural knowledge in ordinary folders that teams can version and share.
- Reusable scripts replace repeated code generation with more consistent, efficient execution.
- Progressive disclosure exposes skill metadata first, then loads skill.md and additional materials when needed.
- File-based tools remain inspectable and modifiable without continuously occupying the context window.

Progressive skill disclosure
Skill information enters context incrementally as the agent needs it.
- Skill metadata — Initially indicates the skill exists.
- skill.md — Provides core instructions and a directory.
- Organized resources — Scripts and other files remain available.
- Skill metadata → skill.md (Read when needed)
- skill.md → Organized resources (Directory identifies files)

### The ecosystem spans foundational, partner, and enterprise knowledge

[4:59](https://www.youtube.com/watch?v=CEvIs9y1uog&t=299s)

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 K-Dense 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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=299s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=299s) [6:10](https://www.youtube.com/watch?v=CEvIs9y1uog&t=370s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=370s) [7:12](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s) [8:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=488s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 334 seconds](https://ai.engineer/api/talk-essay-media/2d8c47164906823f955eb5cd8bb8d4ee91c809ff3ae588cdf5df3709f262d944)

The ecosystem spans foundational, partner, and enterprise knowledge

- Skill categories include foundational capabilities, partner-created product expertise, and organization-specific procedures.
- Foundational examples include professional document editing, EHR data analysis, and Python bioinformatics workflows.
- Partner and enterprise skills encode Stagehand usage, Notion research, internal software practices, and organizational code style.
- Skills range from a basic skill.md file to packages containing executables, scripts, code, and assets.

### Separate runtime, connectivity, and expertise

[8:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=488s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=547s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=488s) [9:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=547s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=609s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 519 seconds](https://ai.engineer/api/talk-essay-media/0754ee5d83081d56d88f1d5df68031c9847bcb598b48bc7f62111ccb3a8e988c)

Separate runtime, connectivity, and expertise

- The agent loop manages model context and token flow, while the runtime provides files and executable code.
- MCP servers provide external tools and data; skills provide procedural expertise for using them.
- Skills can orchestrate multiple MCP tools into more complex externally connected workflows.
- Financial-services and life-sciences offerings combine domain-specific MCP servers with skills.

### Treat sophisticated skills like software

[7:12](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s) [10:09](https://www.youtube.com/watch?v=CEvIs9y1uog&t=609s)

**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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s) [10:09](https://www.youtube.com/watch?v=CEvIs9y1uog&t=609s) [11:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 669 seconds](https://ai.engineer/api/talk-essay-media/4ef0f759aac54abf6146ab402bbf152099532b4cadace32f57d43a7f90c09859)

Treat sophisticated skills like software

- Complex skills can package executables, binaries, scripts, assets, and other supporting files.
- Proposed evaluation tooling would check skill selection, triggering, and resulting output quality.
- Versioning should track skill changes alongside changes in agent behavior.
- Explicit dependencies on other skills, MCP servers, and environment packages could improve runtime predictability.

### Build a shared, evolving layer of procedural knowledge

[11:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s) [12:26](https://www.youtube.com/watch?v=CEvIs9y1uog&t=746s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=800s)

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](https://www.youtube.com/watch?v=CEvIs9y1uog&t=864s) [15:31](https://www.youtube.com/watch?v=CEvIs9y1uog&t=931s) [15:42](https://www.youtube.com/watch?v=CEvIs9y1uog&t=942s)

![Selected presentation frame from Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic at 792 seconds](https://ai.engineer/api/talk-essay-media/caa1f5fc46b2c56a4f6016401abe8bd49b037cded9fcf7761da44e51007374ef)

Build a shared, evolving layer of procedural knowledge

- Shared skill libraries can distribute institutional knowledge across agents, teammates, and the broader community.
- Persistent skills transfer task-specific procedural knowledge to future agent sessions without capturing every form of memory.
- Claude can create skills using a skill creator skill and can acquire, revise, or remove capabilities.
- The computing analogy maps models to processors, agent runtimes to operating systems, and skills to applications.

Agent architecture as a computing stack
Skills form the application layer above agent runtimes and models.
- Skills — Application layer containing domain expertise.
- Agent runtime — Operating-system layer coordinating model execution.
- Model — Processor-like foundation supplying core capability.

## Key takeaways

- A capable general-purpose agent still needs **domain expertise**; reusable skills package that expertise without requiring a different agent architecture for every field. [1:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=80s) [2:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=138s)
- Skills are organized folders containing **procedural instructions, reusable scripts, and supporting assets**, with skill.md acting as the main instruction and navigation file. [2:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=138s) [3:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s) [4:39](https://www.youtube.com/watch?v=CEvIs9y1uog&t=279s)
- **Progressive disclosure** protects the context window by exposing skill metadata first and loading detailed instructions or files only when a task requires them. [3:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s) [4:39](https://www.youtube.com/watch?v=CEvIs9y1uog&t=279s) [9:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=547s)
- In the emerging agent stack, **MCP supplies connectivity** to external tools and data, while skills supply the procedural expertise needed to orchestrate useful workflows. [8:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=488s) [9:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=547s)
- As skills become more sophisticated, teams need software-style **evaluation, versioning, dependency management, and runtime predictability**; the speakers present these as active development priorities. [10:09](https://www.youtube.com/watch?v=CEvIs9y1uog&t=609s) [11:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s)
- Shared, agent-created skills offer a path toward **transferable procedural learning**, but they are not a complete memory system and do not capture every type of information. [12:26](https://www.youtube.com/watch?v=CEvIs9y1uog&t=746s) [13:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=800s) [14:24](https://www.youtube.com/watch?v=CEvIs9y1uog&t=864s)

## Slides

### Year of agents

A timeline traces agent-building talks, MCP’s rising repository stars, Claude Code and the Claude Agent SDK. The speaker sees a shift toward tighter coupling between the model and its runtime environment.

[0:54](https://www.youtube.com/watch?v=CEvIs9y1uog&t=54s) [Timeline showing agent milestones, including Model Context Protocol, Claude Code, and Claude Agent SDK.](https://assets.ai.engineer/sites/aiecode2025/sha256/16307b8812a6c51deb9656b107decdab7bd8c609e119557fa382575466340061.webp)

Year of agents

Timeline: FEB — TODAY

ANTHROPIC
How We Build Effective Agents
Barry Zhang

ANTHROPIC
Model Context Protocol
Integrating LLMs with your tools & data
Mahesh Murag

Model Context Protocol

Star History
Legend: [illegible]
Y-axis: GitHub Stars
Y-axis ticks: 20K, 40K, 60K
X-axis: Date
Timeline: 2025, April, July, October
star-history.com

Welcome to Claude Code research preview
CLAUDE CODE
Press Enter to continue...

Claude Agent SDK

ANTHROPIC

### How we used to think about agents

The earlier model gave each domain its own agent, tools, and scaffolding. The slide shows separate model–tool loops for coding, research, finance, and marketing.

[1:22](https://www.youtube.com/watch?v=CEvIs9y1uog&t=82s) [Four panels depict coding, research, finance, and marketing agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/30ea6f54e803f01e6bd03488701e018b9bebe1d2de542fc112ed9ae623e6c955.webp)

How we used to think about agents

Coding Agent
Research Agent
Finance Agent
Marketing Agent

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Code is the universal interface

A coding agent can serve multiple use cases through code. For a financial report, it can pull data from APIs, organize files, and analyze the data with Python.

[1:37](https://www.youtube.com/watch?v=CEvIs9y1uog&t=97s) [A coding agent connects to icons representing several use cases.](https://assets.ai.engineer/sites/aiecode2025/sha256/dfbdd00ac7cf89b80b650044f76f7f87dca3fb2223d32cd9deefb731761aff07.webp)

Code is the universal interface

Coding Agent
Use cases

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### What’s missing?

The speaker compares agents to a mathematical genius tackling taxes: both need domain expertise to execute reliably, as a tax professional would.

[2:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=140s) [A tax form accompanies hypothetical profiles of a mathematical genius and a tax professional.](https://assets.ai.engineer/sites/aiecode2025/sha256/68d78887d7f4feb78c6f74186cbbe12b5665e9cb84521a2a9120de1ae72cc79a.webp)

What’s missing?

1040 U.S. Individual Income Tax Return
2024
[illegible]

Mahesh
Mathematical Genius
(Hypothetical)

Barry
Tax Professional
(Hypothetical)

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

[2:27](https://www.youtube.com/watch?v=CEvIs9y1uog&t=147s) [A tax form beside hypothetical mathematical genius Mahesh and tax professional Barry.](https://assets.ai.engineer/sites/aiecode2025/sha256/df7409d40f43f580f3b409329cf04327e18e08094ba239b9723b39c076d622e7.webp)

What’s missing?

1040 U.S. Individual Income Tax Return
2024
[illegible]

Mahesh
Mathematical Genius
(Hypothetical)

Barry
Tax Professional
(Hypothetical)

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Introducing Agent Skills

Agent Skills package procedural knowledge in files for agents.

[2:55](https://www.youtube.com/watch?v=CEvIs9y1uog&t=175s) [Orange section slide titled Introducing Agent Skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/c0098820228ad9517fc3f9ae7d1ba8ded2a15626bf74b842475c6ea9eefff67e.webp)

Introducing Agent Skills

ANTHROPIC

AIE / CODE
PRESENTED BY
Google DeepMind

DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### What are Agent Skills?

Agent Skills package procedural knowledge in folders. The example combines a SKILL.md file with supporting documents and a Python script.

[2:59](https://www.youtube.com/watch?v=CEvIs9y1uog&t=179s) [A definition of agent skills beside an example folder containing instructions, documents, and a script.](https://assets.ai.engineer/sites/aiecode2025/sha256/de3e2b0fd490a42e500f29d7e68305fbdd7da1291f09c3824cc6aa02d1527d73.webp)

What are Agent Skills?

Skills are organized collections of files that package composable procedural knowledge for agents

anthropic_brand/
├ SKILL.md
├ docs.md
├ slide-decks.md
└ apply_template.py

ANTHROPIC

AIE / CODE
PRESENTED BY
Google DeepMind

DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Skills are just folders

A skill folder can hold SKILL.md, documents, and a Python script. Teams can version the folder in Git or zip it for sharing.

[3:06](https://www.youtube.com/watch?v=CEvIs9y1uog&t=186s) [An example skill folder containing a SKILL.md file, documents, and a Python script.](https://assets.ai.engineer/sites/aiecode2025/sha256/563ea62d54e7f328326c42ecd2ff6b2e658d1a5986cf62d2f47e37f2236e00d6.webp)

Skills are just folders

anthropic_brand/
├ SKILL.md
├ docs.md
├ slide-decks.md
└ apply_template.py

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Skills can include scripts as tools

The slide styling instructions point to a Python script that updates a PowerPoint file in place. The speaker says Claude saved the script in the skill after repeatedly writing it to style slides.

[3:43](https://www.youtube.com/watch?v=CEvIs9y1uog&t=223s) [A slide pairs slide styling instructions with a Python script that applies a template.](https://assets.ai.engineer/sites/aiecode2025/sha256/228cdcefe84e98d471f1d641162ac518794857afe3a3749bcc17ac278c48df3f.webp)

Skills can include scripts as tools

anthropic/brand_styling/slide-decks.md

## Anthropic Slide Decks

- Intro/outro slides
  - background color: `#141413`
  - foreground color: oat
- Section slides:
  - background color: `#da7857`
  - foreground color: `#141413`

Use the `./apply_template.py` script to update a pptx file in-place.

anthropic/brand_styling/apply_template.py

import sys
from pptx import Presentation

if len(sys.argv) != 2:
    print("USAGE: apply_template.py <pptx>")
    sys.exit(1)

prs = Presentation(sys.argv[1])
for slide in prs.slides:
    ...

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Foundational Skills

Foundational skills give agents general or domain-specific capabilities. Anthropic’s document skills create and edit Office documents; K-Dense’s scientific skills support research tasks such as EHR analysis.

[5:21](https://www.youtube.com/watch?v=CEvIs9y1uog&t=321s) [A slide presents document skills from Anthropic and scientific skills from K-Dense-AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/625403ccec0897c022a67dbcfc31038c54b2a8ce9804020692eeafc09cdf1dd1.webp)

The Skills ecosystem
Foundational Skills

My big day is coming! Help me make a detailed wedding planning checklist for the next 12 months. Organize by timeframe with tasks, vendor categories, and budget considerations.

I want to surprise my wife with a trip to Italy! I have 6 months to save - here's my recent finances. Help me create a plan and a budget in Excel. Where can I save the money?!

I need a business report for my food truck. Create a PDF with charts - best sellers, margin, etc- whatever you think is useful. Make it look great and help me make decisions!

Document Skills
Anthropic

Claude Scientific Skills
License MIT  Skills 120

A comprehensive collection of 120+ ready-to-use scientific skills for Claude, created by the K-Dense team. Transform Claude into your AI research assistant capable of executing complex multi-step scientific workflows across biology, chemistry, medicine, and beyond.

These skills enable Claude to seamlessly work with specialized scientific libraries, databases, and tools across multiple scientific domains:
• Bioinformatics & Genomics - Sequence analysis, single-cell RNA-seq, gene regulatory networks, variant annotation, phylogenetic analysis
• Cheminformatics & Drug Discovery - Molecular property prediction, virtual screening, ADMET analysis, molecular docking, lead optimization
• Proteomics & Mass Spectrometry - LC-MS/MS processing, peptide identification, spectral matching, protein quantification
• Clinical Research & Precision Medicine - Clinical trials, pharmacogenomics, variant interpretation, drug safety, precision therapeutics
• Healthcare AI & Clinical ML - EHR analysis, physiological signal processing, medical imaging, clinical [cut off]

Scientific Skills
K-Dense-AI

Embedded document text: WEDDING PLANNING JOURNEY; Financial Performance Analysis; [illegible]

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

### Partner Skills

Browserbase’s Stagehand skill helps Claude navigate the web; Notion’s skills help it understand and research a Notion workspace.

[5:54](https://www.youtube.com/watch?v=CEvIs9y1uog&t=354s) [Partner Skills slide featuring Browserbase browser automation and Notion Skills for Claude.](https://assets.ai.engineer/sites/aiecode2025/sha256/628ccba1e140773aaebf852292423fa6157f6bd139c9b053299e264d00bfd935.webp)

The Skills ecosystem
Partner Skills

Automate anything in the browser, reliably
Research agent
Task agent
Authenticated agent
Get detailed research with live information
What are some ongoing and active clinical trials for Parkinson’s?
[illegible]
Find me available apartments and their floorplans

Notion Skills for Claude

Notion Skills for Claude are step-by-step guides that teach Claude how to do real work in Notion. Instead of just answering questions, Skills help Claude complete entire workflows—structuring pages the way your team does, updating databases with the right info, following your brand guidelines, and working through your actual patterns.

Use them to turn a spec into an implementation plan, run research that ends up as a beautiful Notion doc, prep for meetings with context already pulled together, or capture decisions into your wiki or task database. It’s a faster way to go from idea to done—and everything ends up organized, shareable, and ready for your team to use.

To get started: Download the .zip below, then upload each Skill to Claude. Once loaded, Claude [illegible]

Browserbase
Notion

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

### Trends in the Skills ecosystem

Skills are becoming more complex and reaching non-developers. They also orchestrate MCP tools: MCP provides external connections, while skills provide expertise.

[8:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=487s) [Trends slide listing more complex, production-grade skills and skills complementing MCP servers.](https://assets.ai.engineer/sites/aiecode2025/sha256/403121b374757e0cd1251494f3d1299664ea4486333c1498912ba1aaa74d5c70.webp)

Trends in the Skills ecosystem

More complex, production-grade skills
Skills complementing MCP servers

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

[8:35](https://www.youtube.com/watch?v=CEvIs9y1uog&t=515s) [Three trends: production-grade skills, skills complementing MCP servers, and non-developers building skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/25f41cd718de1bee339308da5ac29cbba6a3b1ad93859967f4ff1b51cad34029.webp)

Trends in the Skills ecosystem

More complex, production-grade skills
Skills complementing MCP servers
Non-developers building high-value skills

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

### Skills: the complete picture

The agent loop couples a model with a code runtime and connects to MCP servers for outside tools and data. The agent can pull relevant skills into context at runtime for a particular task.

[9:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=573s) [An agent model and code environment form a loop, with arrows connecting the agent to three MCP servers.](https://assets.ai.engineer/sites/aiecode2025/sha256/b625775878d0e5205e4c2e75a1e8b680469df9f68204af1b97e80e5d4724f2c6.webp)

Skills: the complete picture

Agent
</>

MCP server 1
MCP server 2
MCP server 3

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Exploring how Skills evolve: domain offerings

Anthropic's financial services and life sciences offerings each paired Claude with MCP servers and skills for professionals in those domains.

[10:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=608s) [Two panels illustrate Claude for Financial Services and Claude for Life Sciences.](https://assets.ai.engineer/sites/aiecode2025/sha256/99389e76cbc4b2b498082abec4f159650d019abdc028b1eeabad00e103dce97d.webp)

Exploring how Skills evolve

Claude for Financial Services
Claude for Life Sciences

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Exploring how Skills evolve: development practices

Anthropic is exploring evaluation, version history and composition for skills. The example combines brand and PowerPoint skills for branded decks, while a PowerPoint skill references MCP and pandas.

[10:35](https://www.youtube.com/watch?v=CEvIs9y1uog&t=635s) [Three panels illustrate skill evaluation, version history, and composition with other skills and dependencies.](https://assets.ai.engineer/sites/aiecode2025/sha256/a492955e72ab252f97e42242d27bb9a02fe5f2d4c4036f00562a1884db8b6e4a.webp)

Exploring how Skills evolve

Evaluation
Brand Style Skill
Triggering accuracy
8/10 cases correctly triggered
Output quality
Match expected format
Script execution
apply_template.py failed
SKILL.md structure
Valid YAML frontmatter

Versioning
2025-10-11
2025-10-31
2025-11-21

Composability
Branded Decks
Brand Style Skill + PowerPoint Skill
PowerPoint Skill
MCP
pandas

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Exploring how Skills evolve

Five users point toward a shared toolbox. The speakers envision an evolving knowledge base of capabilities, curated by people and agents and shared across an organization.

[12:01](https://www.youtube.com/watch?v=CEvIs9y1uog&t=721s) [Five users point toward a shared toolbox surrounded by capability icons.](https://assets.ai.engineer/sites/aiecode2025/sha256/c7387dc6eacfcc369c89cb255d17ca036dfc8757733af2162c4dd39f76d550c0.webp)

Exploring how Skills evolve

User 1
User 2
User 3
User 4
User 5

ANTHROPIC

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
DON'T BUILD AGENTS, BUILD SKILLS INSTEAD
BARRY ZHANG
Member of Technical Staff
MAHESH MURAG
Member of Technical Staff
ANTHROPIC

### Skills are a concrete step towards continuous learning

The curve sketches a goal: Claude progresses from intelligent with no skills on day 1 to useful with many skills on day 30. Skills retain procedural knowledge for specific tasks.

[13:46](https://www.youtube.com/watch?v=CEvIs9y1uog&t=826s) [A rising curve shows day 1 with no skills and day 5 with a few skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/161ecf017893a8c7788fc47687e15bec9535321d089060c2ef83d177439a9b46.webp)

Skills are a concrete step towards continuous learning

DAY 1
No skills
Intelligent

DAY 5
A few skills
Capable

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

[13:57](https://www.youtube.com/watch?v=CEvIs9y1uog&t=837s) [A rising curve compares day 1 with no skills and intelligence, day 5 with a few skills and capability, and day 30 with many skills and usefulness.](https://assets.ai.engineer/sites/aiecode2025/sha256/94ee634470ba50b2a3f57c98d414ab409ee4da0d51605137760ec4e2945ddf0d.webp)

Skills are a concrete step towards continuous learning

DAY 1
No skills
Intelligent

DAY 5
A few skills
Capable

DAY 30
Many skills
Useful

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

### Moving up the stack

The slide compares models to processors, agents to operating systems, and skills to applications. The speaker hopes skills will open that application layer to people solving concrete problems.

[15:12](https://www.youtube.com/watch?v=CEvIs9y1uog&t=912s) [Nested circles pair models with processors, agents with operating systems, and skills with applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d0cd9fffdc1a2441a1380998e572f363cc2eb66d8b6ed65dce660fc96336b3c.webp)

Moving up the stack

Skills
Applications

Agents
Operating Systems

Models
Processors

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

[15:22](https://www.youtube.com/watch?v=CEvIs9y1uog&t=922s) [Nested circles compare models to processors, agents to operating systems, and skills to applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/b943215cfa2d77707aa4e7c9e82d103c50b811e30cb99089ecee3b475ffad067.webp)

Moving up the stack

Skills
Applications

Agents
Operating Systems

Models
Processors

ANTHROPIC

Interface text:
AI Engineer
Engineering the future of AI

### Stop Building Agents, Build Skills Instead

The speakers propose skills as a way to ship and share capabilities for general agents, and invite viewers to build skills or join Anthropic.

[15:41](https://www.youtube.com/watch?v=CEvIs9y1uog&t=941s) [Closing slide names the presenters and invites viewers to work on and build skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/9aff418589987c5b2e1ebbe7228ec8a730a5f0cf8d693b2b0cd530edb0494fd3.webp)

ANTHROPIC

Stop Building Agents
Build Skills Instead

Barry Zhang
Mahesh Murag

Come work on Skills
anthropic.com/careers

Build Skills
github.com/anthropics/skills

AI Engineer
Engineering the future of AI

### AI Engineer Code Summit

[16:12](https://www.youtube.com/watch?v=CEvIs9y1uog&t=972s) [AI Engineer Code Summit logo and website on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/e6fa4941d251f954cf298a0e2abe49cbab30b636d10741fd1db7f808011c5d5f.webp)

AI Engineer
Code Summit
https://ai.engineer

## Full transcript

[0:00](https://www.youtube.com/watch?v=CEvIs9y1uog&t=0s) [upbeat electronic music] All right, good morning, and thank you for having us again.

[0:24](https://www.youtube.com/watch?v=CEvIs9y1uog&t=24s) Last time we were here, we were still figuring out what an agent even is. Today, many of us are using agents on a daily basis. But we still notice gaps.

[0:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=33s) We still have slop, 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.

[0:44](https://www.youtube.com/watch?v=CEvIs9y1uog&t=44s) In this talk, we'll show you why we stopped building agents and started building skills instead.

[0:51](https://www.youtube.com/watch?v=CEvIs9y1uog&t=51s) A lot of things have changed since our last talk. MCP became the standard for agent connectivity, Claude Code, our first coding agent, launched to the world, and our C-Claude Agent SDK now provides a production-ready agent out of the box.

[1:05](https://www.youtube.com/watch?v=CEvIs9y1uog&t=65s) 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.

[1:15](https://www.youtube.com/watch?v=CEvIs9y1uog&t=75s) Put simply, we think code is all we need.

[1:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=80s) 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.

[1:30](https://www.youtube.com/watch?v=CEvIs9y1uog&t=90s) While customization is still important for each domain, the agent underneath is actually more universal than we thought.

[1:38](https://www.youtube.com/watch?v=CEvIs9y1uog&t=98s) What we realized is that code is not just a use case, but a universal interface to the digital world.

[1:45](https://www.youtube.com/watch?v=CEvIs9y1uog&t=105s) After we built Claude Code, we realized that Claude Code is actually a general purpose agent.

[1:50](https://www.youtube.com/watch?v=CEvIs9y1uog&t=110s) 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. It can analyze it with Python, and then synthesize the insight in all file format, all through code.

[2:04](https://www.youtube.com/watch?v=CEvIs9y1uog&t=124s) The core scaffolding has suddenly become as thin as just bash and file system, which is great and really scalable, but we very quickly run into a different problem,

[2:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=134s) and that problem is domain expertise. Who do you want doing your taxes? Is it gonna be Mahesh, the three hundred IQ mathematical genius, or is it Barry, an experienced tax professional, right?

[2:24](https://www.youtube.com/watch?v=CEvIs9y1uog&t=144s) I would pick Barry every time. I don't want Mahesh to figure out the twenty twenty-five tax code from first principles. I need consistent execution for, from a domain expert.

[2:34](https://www.youtube.com/watch?v=CEvIs9y1uog&t=154s) Agents today are a lot like Mahesh. They're brilliant, but they lack expertise. [laughs]

[2:42](https://www.youtube.com/watch?v=CEvIs9y1uog&t=162s) They can do-- No more slop. 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.

[2:51](https://www.youtube.com/watch?v=CEvIs9y1uog&t=171s) They can't really absorb your expertise super well, and they don't learn over time.

[2:56](https://www.youtube.com/watch?v=CEvIs9y1uog&t=176s) That's why we created Agent Skills. Skills are organized collections of files that package composable procedural knowledge for agents.

[3:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=187s) 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.

[3:19](https://www.youtube.com/watch?v=CEvIs9y1uog&t=199s) 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 for, uh, as a primitive for decades, and we like them, so why change now?

[3:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=213s) 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't really make a change to the tool, so it's just kind of stuck with a cold start problem, and they always live in

[3:50](https://www.youtube.com/watch?v=CEvIs9y1uog&t=230s) 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, a script inside of a skill.

[4:03](https://www.youtube.com/watch?v=CEvIs9y1uog&t=243s) We kept seeing Claude write the same Python script over and over again to apply styling to slides, so we just asked Claude to save it inside of the skill as a tool for his version, uh, f-for his future self.

[4:15](https://www.youtube.com/watch?v=CEvIs9y1uog&t=255s) Now we can just run the script, and that makes everything a lot more consistent and a lot more efficient.

[4:22](https://www.youtube.com/watch?v=CEvIs9y1uog&t=262s) 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.

[4:30](https://www.youtube.com/watch?v=CEvIs9y1uog&t=270s) That's why skills are progressively disclosed. At runtime, only this metadata is shown to the model just to indicate that it has the skill.

[4:39](https://www.youtube.com/watch?v=CEvIs9y1uog&t=279s) When an agent needs to use a skill, it can read in the rest of the SKILL.md, which contains the core instruction and directory for the rest of the folder.

[4:48](https://www.youtube.com/watch?v=CEvIs9y1uog&t=288s) Everything else is just organized for ease of access. So that's all skills are. They're organized folders with scripts as tools.

[4:59](https://www.youtube.com/watch?v=CEvIs9y1uog&t=299s) Since 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.

[5:11](https://www.youtube.com/watch?v=CEvIs9y1uog&t=311s) There are foundational skills, third-party skills created by partners in the ecosystem, and skills built within an enterprise and within teams.

[5:21](https://www.youtube.com/watch?v=CEvIs9y1uog&t=321s) 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.

[5:40](https://www.youtube.com/watch?v=CEvIs9y1uog&t=340s) We're also really excited to see people like K-Dense build scientific research skills that give Claude new capabilities like EHR data analysis and using common Python bioinformatics libraries better than it could before.

[5:56](https://www.youtube.com/watch?v=CEvIs9y1uog&t=356s) 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.

[6:10](https://www.youtube.com/watch?v=CEvIs9y1uog&t=370s) And now Claude equipped with the, the skill and with Stagehand, can now go navigate the web and use a browser more effectively to get work done.

[6:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=380s) And Notion launched a bunch of skills that help Claude better understand your Notion workspace and do deep research over your entire workspace.

[6:30](https://www.youtube.com/watch?v=CEvIs9y1uog&t=390s) 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

[6:51](https://www.youtube.com/watch?v=CEvIs9y1uog&t=411s) 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 Claude Code and teach them about code style best practices and other ways that they want their developers to work internally.

[7:12](https://www.youtube.com/watch?v=CEvIs9y1uog&t=432s) 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 the new capabilities that they didn't have before.

[7:29](https://www.youtube.com/watch?v=CEvIs9y1uog&t=449s) 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.

[7:43](https://www.youtube.com/watch?v=CEvIs9y1uog&t=463s) 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.

[7:58](https://www.youtube.com/watch?v=CEvIs9y1uog&t=478s) 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.

[8:08](https://www.youtube.com/watch?v=CEvIs9y1uog&t=488s) We're also seeing that this ecosystem of skills is complementing the existing ecosystem of MCP 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.

[8:27](https://www.youtube.com/watch?v=CEvIs9y1uog&t=507s) And in these cases, MCP, MCP is providing the connection to the outside world, while skills are providing the expertise.

[8:37](https://www.youtube.com/watch?v=CEvIs9y1uog&t=517s) 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.

[8:49](https://www.youtube.com/watch?v=CEvIs9y1uog&t=529s) Um, 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.

[9:07](https://www.youtube.com/watch?v=CEvIs9y1uog&t=547s) 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.

[9:17](https://www.youtube.com/watch?v=CEvIs9y1uog&t=557s) The first is this agent loop that helps manage the, 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.

[9:34](https://www.youtube.com/watch?v=CEvIs9y1uog&t=574s) 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, the agent more relevant and more effective.

[9:46](https://www.youtube.com/watch?v=CEvIs9y1uog&t=586s) 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 pa- particular task.

[9:58](https://www.youtube.com/watch?v=CEvIs9y1uog&t=598s) Today, giving an agent a new capability in a new m- domain might just involve equipping it with the right set of MCP servers and the right library of skills.

[10:10](https://www.youtube.com/watch?v=CEvIs9y1uog&t=610s) 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

[10:28](https://www.youtube.com/watch?v=CEvIs9y1uog&t=628s) a set of skills that immediately make Claude more effective for professionals in each of these domains.

[10:37](https://www.youtube.com/watch?v=CEvIs9y1uog&t=637s) We're also starting to think about some of the other open questions and areas that we wanna focus on for how skills evolve in the future. As they start to become more complex, we really wanna support developers, enterprises, and other skill builders by starting to treat skills like we treat software.

[10:54](https://www.youtube.com/watch?v=CEvIs9y1uog&t=654s) 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.

[11:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=674s) We'd also like to focus on versioning. As a skill evolves and the resulting agent behavior b- uh, evolves, we want this to be, uh, clearly tracked and to have a clear lineage over time.

[11:26](https://www.youtube.com/watch?v=CEvIs9y1uog&t=686s) 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 gonna 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

[11:47](https://www.youtube.com/watch?v=CEvIs9y1uog&t=707s) 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 Claude.

[12:02](https://www.youtube.com/watch?v=CEvIs9y1uog&t=722s) Finally, a huge part of the value of skills, we think, is gonna come from sharing and distribution. Barry and I think a lot about the future of companies that are deploying these agents at scale.

[12:14](https://www.youtube.com/watch?v=CEvIs9y1uog&t=734s) And the vision that excites us most is one of a collecting and- collective and evolving knowledge base of capabilities that's curated by people and agents inside of an organization.

[12:26](https://www.youtube.com/watch?v=CEvIs9y1uog&t=746s) 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.

[12:46](https://www.youtube.com/watch?v=CEvIs9y1uog&t=766s) 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.

[12:57](https://www.youtube.com/watch?v=CEvIs9y1uog&t=777s) And as this grows and this ecosystem starts to develop even more, this was gonna, this compound value's gonna extend outside of just your org and into the broader community.

[13:05](https://www.youtube.com/watch?v=CEvIs9y1uog&t=785s) 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.

[13:20](https://www.youtube.com/watch?v=CEvIs9y1uog&t=800s) This vision of a evolving knowledge base gets even more powerful when Claude starts to create these skills. We designed skills specifically as a concrete steps towards cont- uh, continuous learning.

[13:32](https://www.youtube.com/watch?v=CEvIs9y1uog&t=812s) When you first start using Claude, this standardized format gives a very important guarantee. Anything that Claude writes down can be used efficiently by a future version of itself. This makes the learning actually transferable.

[13:44](https://www.youtube.com/watch?v=CEvIs9y1uog&t=824s) As you build up the context, skills makes the concept of memory more tangible. They don't capture everything. They, they don't capture every type of information, just procedural knowledge that Claude can use on specific tasks.

[13:57](https://www.youtube.com/watch?v=CEvIs9y1uog&t=837s) We have worked with Claude for quite a while. The flexibility of skills is, matters even more. Claude can acquire new capabilities instantly, evolve them as needed, and then drop the ones that become obsolete.

[14:09](https://www.youtube.com/watch?v=CEvIs9y1uog&t=849s) This is what we have always known, the power of in to- in context learning makes this a lot more cost-effective for information that change on daily basis.

[14:18](https://www.youtube.com/watch?v=CEvIs9y1uog&t=858s) Our goal is that Claude on day 30 of working with you is gonna be a lot better than Claude on day one. Claude can already create skills for you today using our skill-creator skill, and we're gonna continue pushing in that direction.

[14:33](https://www.youtube.com/watch?v=CEvIs9y1uog&t=873s) We're gonna conclude by comparing the agent stack to what we have already seen in computing.

[14:38](https://www.youtube.com/watch?v=CEvIs9y1uog&t=878s) In a rough analogy, models are like processors. Both require massive investment and contain immense potential. They're only so useful by themselves.

[14:50](https://www.youtube.com/watch?v=CEvIs9y1uog&t=890s) Then we start building operating system. The OS made processors far more valuable by orchestrating the processes, resources, and data around the processor. In AI, we believe the agent runtime is starting to play this role.

[15:02](https://www.youtube.com/watch?v=CEvIs9y1uog&t=902s) We're all trying to build the cleanest, most efficient, and most scalable, uh, abstractions to get the right tokens in and out of the model.

[15:11](https://www.youtube.com/watch?v=CEvIs9y1uog&t=911s) But once we have a platform, the real value comes from applications. A few companies build, uh, processors and operating systems, but millions of developers, like us, have built softwares that encoded domain expertise and our unique points of view.

[15:26](https://www.youtube.com/watch?v=CEvIs9y1uog&t=926s) We hope that skills can help us open up this layer for everyone. This is where we get creative and solve concrete pro- problems for ourselves, for each other, and for the world, just by putting stuff in the folder.

[15:38](https://www.youtube.com/watch?v=CEvIs9y1uog&t=938s) So skills are just the starting point.

[15:42](https://www.youtube.com/watch?v=CEvIs9y1uog&t=942s) 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.

[15:57](https://www.youtube.com/watch?v=CEvIs9y1uog&t=957s) And if you're excited about this, come work with us and start building some skills today. Thank you. [audience applauding] [upbeat music]
