Skip to content
Clawdemy

References: Agent Skills and Claude Code

Source material

Section titled “Source material”
Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Introduction to Agent Skills" + "Claude Code 101" +
    "Claude Code in Action"
  License: Anthropic Academy course content is account-gated;
    Clawdemy structurally mirrors the Academy's lesson progression
    as inspiration and cites it as further study. Every substantive
    claim in this lesson is verifiable against the public Anthropic
    documentation.


Primary public-doc anchors (every substantive claim verified
against):
• Anthropic, "Agent Skills" overview (the SKILL.md format, the
   YAML frontmatter rules, progressive disclosure, the three
   surfaces, the security warning)
  https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
• Anthropic, Agent Skills authoring "Best practices" (writing
   tight descriptions; structuring a Skill)
  https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices
• Anthropic, Agent Skills "Quickstart" (running pre-built PPTX +
   XLSX + DOCX + PDF skills in the API)
  https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart
• Anthropic, "Use Skills with the Claude API" guide (the
   skill_id-in-container parameter; the three beta headers)
  https://platform.claude.com/docs/en/build-with-claude/skills-guide
• Anthropic engineering, "Equipping agents for the real world
   with Agent Skills" (the architecture and real-world
   applications post)
  https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
• Claude Code overview at code.claude.com (the agentic-coding-tool
   verbatim definition; the surfaces; the install paths)
  https://code.claude.com/docs/en/overview
• Anthropic, "Use Skills in Claude Code" (the filesystem layout
   at ~/.claude/skills/ and .claude/skills/)
  https://code.claude.com/docs/en/skills
• Anthropic, Claude Code "CLAUDE.md and memory" (the project-root
   instruction file Claude Code reads at session start)
  https://code.claude.com/docs/en/memory
• Anthropic, Open-source Skills repository
  https://github.com/anthropics/skills


Verbatim claims sourced from the public docs:
• Agent Skill definition: "Agent Skills are modular capabilities
   that extend Claude's functionality. Each Skill packages
   instructions, metadata, and optional resources (scripts,
   templates) that Claude uses automatically when relevant"
• Skill vs prompt distinction: "Unlike prompts (conversation-level
   instructions for one-off tasks), Skills load on-demand and
   eliminate the need to repeatedly provide the same guidance
   across multiple conversations"
• Frontmatter rules (name constraints; description constraints;
   reserved words "anthropic" / "claude")
• Progressive disclosure: three levels (metadata; instructions;
   resources) with the token-cost framing
• Three required beta headers for the API surface:
   "code-execution-2025-08-25", "skills-2025-10-02",
   "files-api-2025-04-14"
• ZDR note (verbatim): "This feature is not eligible for Zero
   Data Retention (ZDR). Data is retained according to the
   feature's standard retention policy"
• Cross-surface sharing rule: "Custom Skills do not sync across
   surfaces"
• Security warning verbatim: "Use Skills only from trusted
   sources: those you created yourself or obtained from Anthropic"
• Claude Code definition: "Claude Code is an agentic coding tool
   that reads your codebase, edits files, runs commands, and
   integrates with your development tools. Available in your
   terminal, IDE, desktop app, and browser"


Required attribution: "Based on the structure of the Anthropic
  Academy 'Introduction to Agent Skills', 'Claude Code 101',
  and 'Claude Code in Action' courses
  (https://anthropic.skilljar.com/). This lesson is an
  independent structural mirror in original prose; every
  substantive claim is verified against the public Anthropic
  Claude documentation at https://platform.claude.com/docs/ and
  the Claude Code documentation at https://code.claude.com/docs/.
  Anthropic does not endorse it."

Read this next

Section titled “Read this next”

Going deeper

Section titled “Going deeper”

A short, durable list. Each link is a specific next step inside Track 22.

  • Lesson 11 of this track, “Subagents and Claude Managed Agents.” Where patterns 4 (orchestrator-workers) and 6 (autonomous agent) become Anthropic-managed primitives. Sub-agents are the focused-inner-loop-spawned-from-an-outer-one shape Claude Code surfaces; Managed Agents are the cloud-hosted version.
  • Lesson 12 of this track, “Shipping a Claude application.” Where Skills + Claude Code go to production: usage monitoring per Skill invocation, eval-set discipline, deployment posture for filesystem-based vs API-uploaded Skills, the security-audit cadence for third-party Skills.

Adjacent tracks (the natural next destinations)

Section titled “Adjacent tracks (the natural next destinations)”
  • Track 20 (AI Agents and Tool Use): pick this if you want the full track-level depth on agent design and harness engineering. The Skills + Claude Code composition this lesson sketches at the connector layer becomes a full design treatment there.
  • Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of operational discipline. The version-history + code-review + team-shareability properties of Skills carry the same observability + governance discipline as any other production code.

Where this connects inside the track

Section titled “Where this connects inside the track”

The durable-instructions layer the rest of T22 leans on:

  • Lesson 1 (first call): the agent harness reading Skills still calls messages.create; everything new is the description-routing and the bash-reads-SKILL.md plumbing.
  • Lesson 3 (model selection): routing pattern with Skills is the cleanest place to send easy queries to a smaller model (a Haiku Skill) and hard ones to a larger one (a Sonnet or Opus Skill).
  • Lesson 4 (custom client tools): Claude Code’s Agent SDK lets you give it custom tools (L4); Skills can bundle scripts that the tools call.
  • Lesson 5 (server tools + Anthropic-schema clients): Claude Code uses bash + text_editor (both L5 Anthropic-schema) to read SKILL.md, run bundled scripts, and edit code.
  • Lesson 6 (MCP): Claude Code natively integrates MCP servers via configuration; the same mcp_servers + mcp_toolset shape from L6 sits under the hood.
  • Lesson 7 (prompt caching + context management): CLAUDE.md is the cached system prompt for Claude Code sessions; Skills’ progressive disclosure is a context-engineering pattern complementary to L7’s compaction and tool result clearing.
  • Lesson 8 (agent loop): Claude Code IS an L8-style loop in production. The stop_reason dispatch, the max_iterations cap, the four loop disciplines all apply.
  • Lesson 9 (six patterns): every pattern can be implemented with Skills (routing as a directory of branch Skills; chaining as a chain of Skills; orchestrator-workers as orchestrator + worker Skills; autonomous agent as Claude Code + domain Skills).
  • Lesson 11 (next): Subagents are how patterns 4 and 6 spawn focused inner loops; Claude Managed Agents are the Anthropic-hosted version.
  • Lesson 12 (shipping): per-Skill cost monitoring, the eval-set discipline applied to Skill-routed branches, security-audit cadence for third-party Skills.