Anthropic Just Dropped a 32-Page Playbook for Teaching Claude to Work Like a Real Team Member

You know that moment when you open a new chat with an AI and realize... you have to explain everything from scratch? Your formatting preferences. Your company's style. The five-step process you've already described 47 times.

It's like training a new intern every single morning.

Well, Anthropic apparently got tired of watching people do this, because they just released a 32-page guide dedicated to one thing: teaching Claude to remember how you work. Permanently.

The tool is called Agent Skills, and the concept is deceptively simple. A skill is a folder (yes, a folder) containing a Markdown file with instructions that tells Claude how to handle specific tasks. You teach it once, upload it, and Claude follows those instructions every time the relevant task comes up.

First up, the TL;DR

If you only have ~2 mins, read this.

The guide uses a great analogy: If MCP (the protocol that lets Claude connect to tools like Notion, Asana, and GitHub) is the kitchen, skills are the recipes. You can have the fanciest kitchen in the world, but without recipes, you're staring at a bunch of appliances.

Here's what people are building:

• Document skills that enforce your team's exact formatting, style, and branding across Word docs, presentations, and spreadsheets
• Workflow automations that chain multi-step processes in exact order (create account → setup payment → send welcome email)
• MCP enhancements like Sentry's code review skill that auto-analyzes bugs in GitHub PRs using error monitoring data

The cleverest part? Skills use progressive disclosure. Claude only loads the instructions it needs for the current conversation, so your context window doesn't get clogged with irrelevant instructions.

You can build a working skill in 15-30 minutes using the built-in skill-creator, and admins can deploy skills workspace-wide.

Anthropic also published skills as an open standard, working with partners like Asana, Canva, Figma, Sentry, and Zapier.

The bigger signal here: Anthropic is betting the next leap in AI isn't smarter models, but models that actually know how you work. The guide is the playbook to make that happen. Download it here.

Now, let's dive into all that with a lot more detail.

The Kitchen Analogy (Anthropic's Words, Not Ours)

Think of this guide like a recipe book for AI. The guide uses a really effective metaphor to explain how skills fit into the bigger picture. If you've heard of MCP (Model Context Protocol, the open standard that lets AI tools connect to external services like Notion, Asana, or GitHub), that's the kitchen: access to tools, ingredients, and equipment.

Skills are the recipes: step-by-step instructions on how to create something valuable with all that equipment.

You can have the fanciest kitchen in the world, but without recipes, you're just staring at a bunch of appliances. Same thing with AI. MCP gives Claude access to your tools. Skills tell it how to actually use them the way your team does.

What a Skill Actually Looks Like

At its core, a skill is a folder with a specific structure:

• SKILL.md (required): The instruction file with YAML frontmatter and Markdown body
• scripts/ (optional): Executable code (Python, Bash, etc.)
• references/ (optional): Documentation loaded as needed
• assets/ (optional): Templates, fonts, icons for output

The YAML frontmatter is the most important part. It's how Claude decides whether to load your skill in the first place. It needs two things: a name and a description that includes what the skill does and when to use it.

Here's what a good one looks like:

name: sprint-planner
description: Manages Linear project workflows including sprint planning, task creation, and status tracking. Use when user mentions "sprint", "Linear tasks", "project planning", or asks to "create tickets".

And here's what a bad one looks like:

name: helper
description: Helps with projects.

The difference? Claude uses those descriptions to decide which skills to load for any given conversation. Vague descriptions mean your skill never fires when it should.

Three Types of Skills People Are Building

The guide breaks skills into three categories based on what Anthropic has seen early adopters do:

1. Document & Asset Creation. These are skills for creating consistent, high-quality output like documents, presentations, code, or designs. A good example is Anthropic's own frontend-design skill for building production-grade web interfaces. Also, skills for docx, pptx, xlsx, and PDF creation are already available in Anthropic's public skills repository.
2. Workflow Automation. Multi-step processes that benefit from consistent methodology. Anthropic's own skill-creator skill is a meta example; it walks you through building other skills.
3. MCP Enhancement. Workflow guidance layered on top of MCP tool access. Sentry's code review skill is a standout example here, automatically analyzing and fixing bugs in GitHub pull requests using Sentry's error monitoring data.

The Secret Sauce: Progressive Disclosure

One of the cleverest design decisions in the skills system is how it manages information. Claude doesn't load every skill instruction for every conversation. Instead, it uses a three-level system:

• Level 1 (always loaded): Just the YAML frontmatter. Enough for Claude to know when each skill should be used, without burning through your context window.
• Level 2 (loaded when relevant): The full SKILL.md body. Loaded only when Claude thinks the skill applies to the current task.
• Level 3 (loaded as needed): Additional files in the skill folder. Claude navigates to these only when it needs specific details.

This is a big deal. AI context windows are precious real estate, and loading every instruction for every skill would eat through tokens fast. Progressive disclosure keeps things lean.

How to Actually Build One

The guide recommends starting with 2-3 concrete use cases. Don't try to build a skill that does everything. Start narrow.

Here's the process they outline:

• Step 1: Define use cases. What does a user want to accomplish? What multi-step workflow does it require? Which tools are needed?
• Step 2: Write the SKILL.md. Start with the YAML frontmatter (name + description with trigger phrases), then write clear, specific instructions in Markdown.
• Step 3: Test it. The guide suggests three types of testing: triggering tests (does it load when it should?), functional tests (does it produce correct output?), and performance comparison (is it actually better than no skill?).
• Step 4: Iterate. Skills are living documents. If your skill doesn't fire when it should, add more trigger phrases to the description. If it fires too often, be more specific. If Claude doesn't follow the instructions, make them more concrete.

There's also a built-in shortcut: you can ask Claude itself to help you build skills. Just say "Use the skill-creator skill to help me build a skill for [your use case]" and it'll walk you through the process. According to the guide, you can build a functional skill in 15-30 minutes this way.

Five Patterns Worth Knowing

The guide outlines five patterns that have emerged from early adopters:

• Sequential Workflow Orchestration. For multi-step processes that need to happen in a specific order (e.g. customer onboarding: create account → setup payment → create subscription → send welcome email).
• Multi-MCP Coordination. For workflows that span multiple services. Example: exporting from Figma, storing in Drive, creating tasks in Linear, and notifying the team in Slack; all in one coordinated flow.
• Iterative Refinement. For output that improves with rounds of review. Generate a draft, run validation, fix issues, repeat until quality threshold is met.
• Context-Aware Tool Selection. When the right action depends on context. Large files go to cloud storage, collaborative docs go to Notion, code goes to GitHub.
• Domain-Specific Intelligence. When you're embedding specialized knowledge beyond tool access, like compliance rules for payment processing.

Who This Is Actually For

The guide is pitched at three audiences: developers who want Claude to follow specific workflows, power users who want consistency, and teams looking to standardize how Claude works across their organization.

But here's the real story. If you're someone who uses Claude daily and finds yourself re-explaining the same things over and over, skills are basically your escape hatch. Admins can even deploy skills workspace-wide (as of December 2025), so an entire team can benefit from one person's setup work.

You can upload skills through Claude.ai settings, place them in the Claude Code skills directory, or use them programmatically via the API. Anthropic also published the API reference for creating skills and documentation for using skills in the Agent SDK.

The Bigger Picture

Anthropic has published Agent Skills as an open standard. Like MCP, they want skills to be portable across tools and platforms; the same skill should work whether you're using Claude or another AI. They've been collaborating with partners including Asana, Atlassian, Canva, Figma, Sentry, and Zapier on this.

The public skills repository on GitHub already has a growing collection of Anthropic-created skills you can customize, and the Claude Developers Discord is the place to go for questions. You can also file bug reports and feature requests on GitHub.

For more depth, Anthropic has published a series of companion resources:

• Introducing Agent Skills (blog announcement)
• Skills Explained: How Skills Compares to Prompts, Projects, MCP, and Subagents (comparison guide)
• How to Create Skills for Claude: Steps and Examples (step-by-step walkthrough)
• Improving Frontend Design Through Skills (case study)
• Skill Authoring Best Practices (developer docs)
• API Overview (for programmatic use)
• MCP Getting Started Guide (for adding tool access alongside skills)
• Getting Started with Local MCP Servers on Claude Desktop (help center walkthrough)

Here's the bottom line: AI tools have spent the last two years getting smarter. Skills are Anthropic's bet that we can now teach models how you work. The 32-page guide is the playbook to make that happen. You can download the full guide here.