The Complete Guide to Agent Skills: Andrew Ng × Anthropic Joint Course Breakdown

What Are Agent Skills

DeepLearning.ai, Andrew Ng's platform, has once again partnered with Anthropic to launch a hands-on course on Agent Skills, taught by instructor Ellie Sherwick. The course centers on a concept that is rapidly becoming an industry standard: how to equip Claude Code and other AI agents with new execution capabilities through "skills."

The rise of Agent Skills stems from a fundamental shift in how large language models (LLMs) operate — moving from single-turn conversations to autonomous task execution. Early AI applications relied heavily on prompt engineering, requiring developers to manually re-describe context and business rules with every interaction. This was inefficient and hard to reuse across teams. Skills borrow the core ideas of "function encapsulation" and "modular design" from software engineering, packaging domain knowledge and execution logic into reusable, standardized units. While this places Skills in the same evolutionary lineage as OpenAI's GPT Actions and LangChain's Tool ecosystem, Skills place greater emphasis on open, cross-platform standards — much like how REST APIs standardized the web services landscape.

Simply put, a Skill is a folder of instructions that extends an agent's capabilities with specialized knowledge. When you have a workflow you need an agent to repeatedly execute, instead of re-explaining the process each time, you package it as a Skill so the agent automatically knows how to perform it. That's the core value proposition — codifying repetitive domain knowledge so it can be written once and reused everywhere.

Notably, Skills have now become an open standard. This means they follow a unified format specification and can run on any agent product that supports Skills. Developers build a skill once and deploy it across multiple agent platforms, significantly reducing migration and reuse costs.

Skill File Structure and How It Works

skill.md: The Core File of Every Skill

Every Skill must include a skill.md Markdown file, which contains three essential elements:

• name: A unique identifier for the skill
• description: Explains what the skill does and when to use it
• main instructions: The core execution logic of the skill

The main instructions can also reference other files, including scripts, additional Markdown documents, and asset files such as templates and images. This modular structure keeps complex skills readable while remaining easy to maintain long-term.

Progressive Disclosure: The Key Design for Saving Context

Skills employ a Progressive Disclosure mechanism — arguably the most noteworthy design choice in the entire system.

Progressive disclosure is a foundational principle in UX design: only surface relevant information when users need it, avoiding cognitive overload. Applying this to AI agent design reflects a systems-engineering mindset focused on optimal resource utilization. In Skills' implementation, this mechanism is technically analogous to "lazy loading" in databases — the index (name + description) stays in memory at all times, while the full data (detailed instructions) is loaded on demand.

To appreciate the depth of this design, it helps to understand the resource constraints of a context window. A context window is the maximum amount of text an LLM can process in a single pass, measured in tokens (1 token ≈ 0.75 English words). While Claude 3 models support context windows of up to 200K tokens, longer contexts mean higher compute costs, slower inference, and the "Lost in the Middle" phenomenon — where a model's attention to information positioned in the middle of the context significantly degrades. Progressive disclosure is an engineering solution specifically designed for this structural limitation.

A skill's name and description always reside in the agent's context window, but detailed instructions are not pre-loaded in full. Only when a user request matches a skill's description does the agent load that skill's complete instructions — and only if necessary, the referenced files and assets.

This design allows a large number of skills to be registered without significant performance overhead. Theoretically, the only limit on the number of supported skills is the token count consumed by description text. As AI applications scale to the enterprise level — where an organization might define hundreds of business process skills — this on-demand activation strategy becomes critically important.

What an Agent Needs to Execute a Skill

For an agent to fully execute a Skill, it needs the following tool support:

1. File system access: To read and write relevant files
2. Batch/execution tool (Bash Tool): To run code instructions

These tools allow the agent to truly execute the operations a skill requires, rather than merely "understanding" the instructions.

More powerfully, Skills can be combined with MCP (Model Context Protocol) and subagents to build sophisticated agent workflows.

MCP (Model Context Protocol) is an open protocol released by Anthropic in late 2024, designed to standardize how AI models connect to external data sources and tools — conceptually similar to USB-C, which provides a unified interface regardless of the device being connected. MCP uses a client-server architecture: the MCP Server exposes tools, resources, and prompt templates; the MCP Client (typically an AI host application) calls them on demand. MCP has already gained support from major players including OpenAI and Google DeepMind, and is on track to become the de facto standard for AI tool invocation.

Subagents are the fundamental building blocks of multi-agent systems. In single-agent architectures, all tasks share a single context window, which can lead to context contamination and task interference. The subagent pattern breaks complex tasks into multiple independent subtasks, each with its own isolated context, focused on a single responsibility, returning results to an orchestrator upon completion. This architecture draws on microservices principles from software engineering: loose coupling, high cohesion, and independent scaling.

The three components divide responsibilities clearly and efficiently:

• The agent uses MCP to retrieve data from external sources, and relies on a Skill to understand how to process or efficiently query that data;
• Meanwhile, it can delegate subtasks to subagents with their own isolated contexts — and those subagents can themselves call Skills for specialized knowledge.

"MCP fetches the data, Skills encode the business logic, subagents handle the division of labor" — this combination forms a flexible, scalable production-grade agent architecture.

Course Walkthrough: From Claude.ai to the Agent SDK

The course guides learners through a series of progressively complex hands-on projects, covering how Skills can be applied across different scenarios.

Stage 1: Starting with Claude.ai

The course begins by creating a skill for a Marketing Campaign in Claude.ai, combining it with pre-built Excel and PowerPoint skills to demonstrate how an agent can automatically handle complex office document tasks.

Stage 2: Moving to the API and Claude Code

Next, learners create two skills corresponding to content creation and data analysis workflows, testing them via the Claude API.

Skills are then applied in the Claude Code environment for code review and automated testing — a highly practical core scenario for developers.

Stage 3: Building a Research Agent

In the final stage, learners use the Claude Agent SDK to build a complete Research Agent that integrates multi-source research results through a dedicated Skill. The Agent SDK natively supports orchestration primitives for "spawning subagents and waiting for their completion," enabling parallel processing. For example, a research agent can simultaneously spawn multiple subagents to search different data sources, then have the main agent aggregate the results — dramatically improving information-gathering efficiency. This capstone project ties together all the concepts covered throughout the course.

Conclusion and Reflections

The emergence of Agent Skills marks a pivotal transition for AI agents — from "general-purpose conversation" to "specialized execution." The core problem they solve is: how to enable agents to reliably and reusably master domain-specific workflows.

The establishment of an open standard means Skills won't be locked into a single platform, which is vital for the healthy development of the broader AI ecosystem. The progressive disclosure mechanism reflects mature engineering thinking under the constraint of limited context resources — essentially migrating the UX principle of "minimizing cognitive load" to the architectural layer of AI systems. For developers looking to bring AI agents into real business scenarios, mastering the combined use of Skills, MCP, and subagents will become an indispensable core competency.

If you're exploring how to integrate AI agents into concrete business workflows, this course — built through the collaboration of Andrew Ng's team and Anthropic — offers a clear, structured, and progressively challenging hands-on path.

Key Takeaways