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)