跳转至

A Guide to Anthropic's Internal Skill Ecosystem

Claude Code is a powerful AI-driven programming terminal, but its true potential lies in its Skills system. Many developers treat Skills merely as simple Markdown prompt files, but that significantly underestimates their capability. In reality, a Skill is a comprehensive context-engineering framework and workflow orchestrator.

Thariq, a core developer on Anthropic's internal Claude Code team, recently shared insights from their use of hundreds of internal Skills. This is more than just a prompt-engineering guide; it's a systemic approach to integrating AI into complex software engineering workflows.


Beyond the Document: Skills as File Systems

A common misconception is that a Skill is just an isolated text file. A true Skill is a structured folder system. It can contain core instructions, scripts, test assets, configuration templates, and even local databases. The Agent can autonomously explore, read, and execute tools within this file system.

If a standard prompt is like a sticky note saying "make pasta tonight," a Skill is providing the AI chef with the entire cookbook, a full kitchen, and a pantry of prepped ingredients. By configuring dynamic Hooks and parameters, you can trigger Skills precisely, orchestrating complex tasks while optimizing token usage.


Nine Golden Use Cases

Based on hundreds of high-frequency Skills used at Anthropic, these best practices fall into nine core categories. Effective Skills are single-purpose with clear boundaries; less effective ones often try to do too much at once.

1. Library & API Reference

These Skills teach the model how to correctly interact with specific frameworks or APIs—especially private internal libraries or public ones where Claude might hallucinate or use outdated syntax.

  • Design Tip: Include a catalog of reference code snippets and a "gotchas" guide.
  • Examples: billing-lib (internal billing logic/edge cases), frontend-design (aligning with company design systems).

2. Product Verification

Ensures code is not just functional but logically correct. These Skills often leverage external tools like Playwright, Selenium, or tmux to drive headless browsers or terminals.

  • Advanced Tactic: Have Claude record screen sessions to trace testing, or enforce rigorous programmatic state assertions at every workflow step.

3. Data Fetching & Analysis

Connects the AI to your organization's data streams and monitoring dashboards. These contain authenticated data-fetching scripts, database schemas, and common query patterns.

  • Examples: cohort-compare (automated user retention analysis), funnel-query (extracting conversion funnels from core tables).

4. Business Process & Team Automation

Automates repetitive team coordination and synchronization.

  • Examples: standup-post (aggregating tickets, PRs, and Slack messages to generate a "delta-only" status report), weekly-recap.

5. Code Scaffolding & Templates

Generates complex architectural skeletons. This ensures that new services come pre-baked with team-standard logging, routing, and authentication layers.

  • Examples: new-migration (database migration templates with index optimizations), create-app (service bootstrapping).

6. Code Quality & Review

Acts as a rigorous virtual reviewer to enforce team standards.

  • Design Tip: Use deterministic scripts alongside AI analysis for robust quality control.
  • Example: adversarial-review (starts a sub-agent with an adversarial perspective to stress-test the code).

7. CI/CD & Deployment

Safely manages merge and release pipelines.

  • Examples: babysit-pr (monitors unstable CI, resolves merge conflicts), cherry-pick-prod (automated emergency patches).

8. Incident Runbooks

Translates senior engineer troubleshooting experience into executable workflows. It takes an incident symptom (e.g., Slack alert or error log) and traverses multiple systems to produce a structured root-cause report.

  • Example: log-correlator (automatically links cross-service traces via Request ID).

9. Infrastructure Operations

Handles routine maintenance while maintaining strict safety guardrails.

  • Example: <resource>-orphans (identifies and cleans up abandoned resources after a mandatory human confirmation period).

Advanced Tactics: Building Industrial-Grade Skills

Once you have defined your use case, use these techniques to build resilient, production-ready tools.

Focus on the "Unknowns"

Claude already knows general programming patterns. Focus your Skill on internal knowledge, team-specific conventions, and information that forces Claude to break its default "AI-style" habits.

Prioritize the "Gotchas"

The highest ROI section of any Skill is the Gotchas list. Whenever Claude repeatedly fails on a specific edge case, add it to your documentation. It is a dynamic, growing knowledge base that directly increases accuracy.

Progressive Context Disclosure

Avoid dumping everything into a massive Markdown file. Use a main entry file (SKILL.md) for triggers and high-level workflows, and keep detailed API parameters and templates in assets/ or references/ directories. Claude will access them only when needed.

Initialization & Configuration

Use a config.json file for settings like Slack channels. If configuration is missing, instruct the agent to pause and use AskUserQuestion to prompt the user for input.

State Memory

Enable long-term memory for Skills. By storing operation logs (e.g., standups.log) in a stable path like ${CLAUDE_PLUGIN_DATA}, the Agent can analyze changes over time across different sessions.

Tactical Hooks

Use Skill-level lifecycle hooks to create safety guardrails. For instance, you could create a /careful hook that triggers an automatic human confirmation prompt before any high-risk command like rm -rf or DROP TABLE.


Distribution and Evolution

  • Repository Integration: For small teams, store Skills in /.claude/skills within the main codebase.
  • Marketplace Distribution: As organizations scale, package Skills as Plugins to allow teams to install only what they need.
  • Data-Driven Iteration: Use PreToolUse hooks to log Skill usage. Identify high-value tools to prioritize and deprecate "zombie" skills to keep the environment lean.