anthropics/skills — Skills: Claude's Dynamic Instruction Library
Transcript
QuickFacts
Welcome to the skills repository. Seventeen self-contained instruction sets. Each one a playbook that extends what Claude can do. This is the library behind the curtain.
QuickFacts
Four hundred nineteen files. Thirty-eight thousand lines. Languages ranging from Markdown to TypeScript. But the real inventory lives in the skills themselves: document manipulation, developer tooling, generative art, enterprise workflows. All orchestrated through instruction, not compilation.
PlainEnglish
Each skill is a folder with a manifest at its heart. The manifest has two parts. First, the card catalog: metadata always visible, a description that acts as the routing key. When Claude receives a request, it scans these descriptions—'use this skill whenever the user wants to manipulate Word documents.' If it matches, the skill loads. Second, the instruction set: markdown body, workflows, code examples, bundled resources. The body is typically five hundred lines. But the bundled folders—scripts, references, assets—can contain gigabytes. Progressive disclosure. You never load the entire library, just what you need for the current chapter.
Architecture
The repository is organized like a library with four wings. Document skills at the top—docx, pdf, pptx, xlsx—these are source-available production implementations. The actual skills powering Claude's document capabilities. Below them, developer tooling: mcp-builder for Model Context Protocol servers, claude-api covering eight languages, webapp-testing for Playwright automation. Then the creative wing: canvas-design with eighty-four fonts, algorithmic-art for p5.js, slack-gif-creator for animated emojis. At the bottom, the meta-layer: skill-creator, the skill that teaches Claude how to write skills. It includes nine Python scripts, an evaluation framework, and an HTML viewer for iterative refinement. This is infrastructure that builds infrastructure.
Architecture
Here's how triggering works. You send a request—create a Word document. Claude scans the catalog: every skill's description in memory. The docx skill's description says 'use whenever the user wants to create, read, edit, or manipulate Word documents.' Match. Claude loads the SKILL.md body—five hundred ninety lines of creation workflows, XML references, anti-patterns. As it executes, it may pull bundled resources on demand: the validation script, the unpacker, fonts. This isn't hard-coded behavior. It's instruction following at scale. The skill is the script. Claude is the actor.
Architecture
The document skills teach two approaches. For simple creation—use the library. Docx-js for Word, pptxgenjs for PowerPoint, openpyxl for Excel. But for complex repairs—lifting the hood. A DOCX is a ZIP archive. Unpack it with the bundled Python script. Inside: raw XML. Edit it surgically with the Edit tool—string replacements guided by the skill's XML reference sections. Every element order requirement, every attribute constraint, every pitfall documented. Then repack into a valid DOCX. Validate with the bundled checker. This is mechanic-level access. The skills are the service manual.
Architecture
The dependency landscape spans five layers. Application tier: document libraries—docx-js, pptxgenjs, openpyxl, pypdf, reportlab. Services: Anthropic SDK for eight languages, MCP SDK for protocol servers, Playwright for browser automation. UI: p5.js for generative art, Vite and Parcel for bundling, Tailwind and shadcn for modern frontends. Data: pandas for analysis, Pillow for image manipulation. DevOps: LibreOffice for format conversion, WebFetch for pulling live documentation. None of this is compiled or shipped as a binary. It's loaded on demand, orchestrated by instructions in markdown files. The skills are dependency managers, build systems, and runtime environments—all expressed as prose.
Architecture
The mcp-builder skill exemplifies structured workflows. Four phases. First, deep research: Claude fetches the MCP specification sitemap from modelcontextprotocol.io, then uses WebFetch to load the TypeScript SDK README from GitHub. Second, implementation: write the server with language-specific patterns—Zod for TypeScript input validation, outputSchema for structured responses, tool annotations like readOnlyHint and destructiveHint. Third, review: check for code duplication, consistent error handling, run the MCP Inspector. Fourth, create evaluations: use the read-only tools to explore the integration target, then generate ten complex evaluation questions with verified answers, output as XML. This is Claude teaching Claude how to build infrastructure.
Architecture
Canvas-design and algorithmic-art share a two-phase ritual. First, generate a philosophy: a named aesthetic movement with four to six paragraphs on form, color, composition. This isn't a prompt—it's a conceptual anchor. Second, express the philosophy visually. Canvas-design outputs PDF or PNG with sophisticated composition, minimal text, fonts pulled from eighty-four bundled typefaces. Algorithmic-art generates p5.js code with seeded randomness, parametric controls, flow fields. The philosophy phase forces intentionality. The skills explicitly warn against generic AI aesthetics: no purple gradients, no centered layouts, no Inter font. The output must look 'meticulously crafted, the product of deep expertise, painstaking attention.' It's art direction encoded as instruction.
Architecture
Skill-creator is the meta-layer. You tell Claude you want a skill for API documentation. Claude captures intent: what should it enable, when should it trigger, what's the output format. It drafts a SKILL.md with name, description, instructions. Then it creates test cases—three prompts with expected outputs and assertions. It spawns six subagents in parallel: three with the new skill, three without. While they run, Claude drafts programmatic checks: 'has Overview section', 'examples use Python SDK'. Subagents finish. Claude grades each output against assertions, aggregates into benchmark.json, launches an HTML eval viewer. You review outputs in the browser, leave feedback in textboxes: 'examples should use Python SDK, not curl.' Click submit. Claude reads feedback.json, edits the SKILL.md, reruns iteration two. Repeat until the skill works. Then optionally optimize the description: generate twenty trigger queries, test accuracy, iterate improvements. Finally, package into a .skill file. This is film editing as code. Draft, screen, review, re-edit.
Architecture
Claude-api is the most architecturally complex skill. Eight language-specific folders: Python, TypeScript, Java, Go, Ruby, C#, PHP, cURL. Each has quickstart guides and streaming examples. Above them, a shared directory with sixteen cross-language concept files: tool use, prompt caching, Managed Agents—that's server-hosted stateful agents with per-session containers—model migration, batch processing, Files API. When Claude needs to explain the Messages API in Java, it loads java slash quickstart, then references shared slash tool-use for the conceptual layer. The skill includes a language detection tree and a decision framework: single call versus workflow versus agent. This is documentation as code, factored for reuse across eight ecosystems.
Community
The repository shows a singular authorial presence. Lance Martin. One contributor, one commit in the last ninety days, six days since the last push. But don't mistake this for abandonment. This is a curated library, not a community project. One branch, zero tags. No versioning, no releases. The skills are live documentation—updated when capabilities change, not on a schedule. The activity signal reads active, but the real signal is in the skill count: seventeen production-grade instruction sets. This is infrastructure as editorial work. Quality over velocity.
PlainEnglish
This is instruction architecture. Where code is prose and prose is executable. A system designed not for compilation, but for comprehension. Claude reads markdown. Claude follows workflows. Claude loads dependencies on demand. The skills are not a library in the traditional sense—they're a runtime environment where the interpreter is an AI and the syntax is natural language. Four hundred nineteen files, thirty-eight thousand lines, but the real complexity is in the orchestration: progressive disclosure, description-based triggering, multi-phase workflows, evaluation frameworks. This is what infrastructure looks like when you build for intelligence instead of silicon.
How this was made
Lenzon read anthropics/skills and generated this walkthrough automatically. The narration above is the transcript of what it says.
Explain a pull request from your own repo
Point Lenzon at a repo or a pull request and get a narrated walkthrough like this one.
Try it